每天一例多线程[day19]-----JDK实现Future的用法

Future模式非常适合在处理耗时很长的业务逻辑时使用，可以有效减小系统的响应时间，提高系统的吞吐量。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class UseFuture implements Callable<String>{
	private String para;
	
	public UseFuture(String para){
		this.para = para;
	}
	
	/**
	 * 这里是真实的业务逻辑，其执行可能很慢
	 */
	@Override
	public String call() throws Exception {
		//模拟执行耗时
		Thread.sleep(5000);
		String result = this.para + "处理完成";
		return result;
	}
	
	//主控制函数
	public static void main(String[] args) throws Exception {
		String queryStr = "query";
		//构造FutureTask，并且传入需要真正进行业务逻辑处理的类,该类一定是实现了Callable接口的类
		FutureTask<String> future = new FutureTask<String>(new UseFuture(queryStr));
		
		FutureTask<String> future2 = new FutureTask<String>(new UseFuture(queryStr));
		//创建一个固定线程的线程池且线程数为1,
		ExecutorService executor = Executors.newFixedThreadPool(2);
		//这里提交任务future,则开启线程执行RealData的call()方法执行
		/**
		 * 线程池中的submit和execute方法的区别：
		 *  第一点是submit可以传入实现Callable接口的实例对象
		 *  第二点是submit方法有返回值
		 */
		// f1.get() 如果执行完毕则返回null
		Future f1 = executor.submit(future);		
		Future f2 = executor.submit(future2);
		System.out.println("请求完毕");
		
		try {
			//这里可以做额外的数据操作，也就是主程序执行其他业务逻辑
			System.out.println("处理实际的业务逻辑...");
			Thread.sleep(1000);
		} catch (Exception e) {
			e.printStackTrace();
		}
		/**
		 * future.get方法异步等待获取线程池的处理的最终结果
		 * 如果call()方法没有执行完成,则依然会进行等待
		 *
		 */
		System.out.println("数据：" + future.get());
		System.out.println("数据：" + future2.get());
		executor.shutdown();
	}

}

打印：

请求完毕
处理实际的业务逻辑...
数据：query处理完成
数据：query处理完成

分析：我们在主函数中定义两个FutureTask，并分别传入实现了Callable接口的对象，定义一个固定数量线程池，将FutureTask对象submit进线程池，每个JDK实现的线程池都有execute和submit两个方法，这两个方法的区别：

1 submit可以传入实现Callable接口的实例对象

2 submit方法有Future类型返回值（这个返回的Future对象有个get方法，可以返回线程池中提交的对应任务是否执行完毕，是则返回null）

我们可以通过定义的FutureTask实例对象的get方法去异步获取线程池中Callable对象的处理结果，如果call()没有执行完毕，则会继续等待。