并发编程09--Callable、Future

Callable

在Java中，创建线程一般有两种方式，一种是继承Thread类，一种是实现Runnable接口。然而，这两种方式的缺点是在线程任务执行结束后，无法获取执行结果。我们一般只能采用共享变量或共享存储区以及线程通信的方式实现获得任务结果的目的。

不过，Java中，也提供了使用Callable和Future来实现获取任务结果的操作。Callable用来执行任务，产生结果，而Future用来获得结果。

Callable接口与Runnable接口是否相似，查看源码，可知Callable接口的定义如下：

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

可以看到，与Runnable接口不同之处在于，call方法带有泛型返回值V。

Future常用方法

V get() ：获取异步执行的结果，如果没有结果可用，此方法会阻塞直到异步计算完成。

V get(Long timeout , TimeUnit unit) ：获取异步执行结果，如果没有结果可用，此方法会阻塞，但是会有时间限制，如果阻塞时间超过设定的timeout时间，该方法将抛出异常。

boolean isDone() ：如果任务执行结束，无论是正常结束或是中途取消还是发生异常，都返回true。

boolean isCanceller() ：如果任务完成前被取消，则返回true。

boolean cancel(boolean mayInterruptRunning) ：如果任务还没开始，执行cancel(...)方法将返回false；如果任务已经启动，执行cancel(true)方法将以中断执行此任务线程的方式来试图停止任务，如果停止成功，返回true；当任务已经启动，执行cancel(false)方法将不会对正在执行的任务线程产生影响(让线程正常执行到完成)，此时返回false；当任务已经完成，执行cancel(...)方法将返回false。mayInterruptRunning参数表示是否中断执行中的线程。

通过方法分析我们也知道实际上Future提供了3种功能：

1. 能够中断执行中的任务
2. 判断任务是否执行完成
3. 获取任务执行完成后额结果。

我们通过简单的例子来体会使用Callable和Future来获取任务结果的用法。

public class TestMain {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		ExecutorService executor = Executors.newCachedThreadPool();
		Future<Integer> future = executor.submit(new AddNumberTask());
		System.out.println(Thread.currentThread().getName() + "线程执行其他任务");
		Integer integer = future.get();
		System.out.println(integer);
		// 关闭线程池
		if (executor != null)
			executor.shutdown();
	}

}

class AddNumberTask implements Callable<Integer> {
	public AddNumberTask() {
	}
	@Override
	public Integer call() throws Exception {
		System.out.println("####AddNumberTask###call()");
		Thread.sleep(5000);
		return 5000;
	}
}

FutureTask

FutureTask 是基本的实现了Future和runnable接口，可以把FutureTask实例传入到Thread中，在一个新的线程中执行，可以从FutureTask中通过get取到任务的返回结果，也可以取消任务执行（通过interreput中断）。

• FutureTask可用于异步获取执行结果或取消执行任务的场景，可以通过FutureTask的get方法异步获取执行结果。
• FutureTask还可以确保即使调用了多次run方法，它都只会执行一次Runnable或者Callable任务，或者通过cancel取消FutureTask的执行等
   

public class FutureTaskForMultiCompute {
 
	public static void main(String[] args) throws InterruptedException,
			ExecutionException {
		FutureTaskForMultiCompute inst = new FutureTaskForMultiCompute();
		// 创建任务集合
		List<FutureTask<Integer>> taskList = new ArrayList<FutureTask<Integer>>();
		ExecutorService execut = Executors.newScheduledThreadPool(5);
		for (int i = 0; i < 10; i++) {
			// 传入Callable对象创建FutureTask对象
			// inst.new ComputeTask(i, " "+i); 不太明白什么意思
			FutureTask<Integer> task = new FutureTask<Integer>(
					inst.new ComputeTask(i, "" + i));
			// 把多个future放在集合中
			taskList.add(task);
			// 提交给线程池执行任务，也可以通过exec.invokeAll(taskList)一次性提交所有任务;
			execut.submit(task);
			System.out.println("所有计算任务提交完毕, 主线程接着干其他事情！");
		}
		Integer result = 0;
		// 从future中取出值来
		for (FutureTask<Integer> future : taskList) {
			result = result + future.get();
		}
		// 打印求出来的值
		System.out.println("result=" + result);
	}
 
	public class ComputeTask implements Callable<Integer> {
		private Integer result = 0;
		private String taskName = ""; 
		ComputeTask(Integer result, String taskName) {
			this.result = result;
			this.taskName = taskName;
			System.out.println("生成子线程计算任务: " + taskName);
		}
		public String getTaskName() {
			return this.taskName;
		}
 
		@Override
		public Integer call() throws Exception {
			for (int i = 0; i < 10; i++) {
				result += i;
			}
			Thread.sleep(5000);
			System.out.println("子线程计算任务: " + taskName + " 执行完成!");
			return result;
		}
	}
}

Future模式

Future模式的核心在于：去除了主函数的等待时间，并使得原本需要等待的时间段可以用于处理其他业务逻辑

Futrure模式:对于多线程，如果线程A要等待线程B的结果，那么线程A没必要等待B，直到B有结果，可以先拿到一个未来的Future，等B有结果是再取真实的结果。

在多线程中经常举的一个例子就是：网络图片的下载，刚开始是通过模糊的图片来代替最后的图片，等下载图片的线程下载完图片后在替换。而在这个过程中可以做一些其他的事情。

首先客户端向服务器请求RealSubject，但是这个资源的创建是非常耗时的，怎么办呢？这种情况下，首先返回Client一个FutureSubject,以满足客户端的需求，于此同时呢，Future会通过另外一个Thread 去构造一个真正的资源，资源准备完毕之后，在给future一个通知。如果客户端急于获取这个真正的资源，那么就会阻塞客户端的其他所有线程，等待资源准备完毕。

模拟Future

公共数据接口，FutureData和RealData都要实现。

public interface Data {
	public abstract String getRequest();
}

FutureData,当有线程想要获取RealData的时候，程序会被阻塞。等到RealData被注入才会使用getReal()方法。

public class FurureData implements Data {

	public volatile static boolean ISFLAG = false;
	private RealData realData;
	public synchronized void setRealData(RealData realData) {
		// 如果已经获取到结果，直接返回
		if (ISFLAG) {
			return;
		}
		// 如果没有获取到数据,传递真实对象
		this.realData = realData;
		ISFLAG = true;
		// 进行通知
		notify();
	}

	@Override
	public synchronized String getRequest() {
		while (!ISFLAG) {
			try {
				wait();
			} catch (Exception e) {
			}
		}
		// 获取到数据,直接返回
		return realData.getRequest();
	}
}

真实数据RealData

public class RealData implements Data {
	private String result;

	public RealData(String data) {
		System.out.println("正在使用data:" + data + "网络请求数据,耗时操作需要等待.");
		try {
			Thread.sleep(3000);
		} catch (Exception e) {

		}
		System.out.println("操作完毕,获取结果...");
		result = "haha";
	}

	@Override
	public String getRequest() {
		return result;
	}
｝

FutureClient 客户端

public class FutureClient {
	public Data request(String queryStr) {
		FurureData furureData = new FurureData();
		new Thread(new Runnable() {

			@Override
			public void run() {
				RealData realData = new RealData(queryStr);
				furureData.setRealData(realData);
			}
		}).start();
		return furureData;
	}
}

调用者：

public class Main {
	public static void main(String[] args) {
		FutureClient futureClient = new FutureClient();
		Data request = futureClient.request("请求参数.");
		System.out.println("请求发送成功!");
		System.out.println("执行其他任务...");
		String result = request.getRequest();
		System.out.println("获取到结果..." + result);
	}
}

调用者请求资源，client.request("name"); 完成对数据的准备

当要获取资源的时候，data.getResult() ，如果资源没有准备好isReady = false;那么就会阻塞该线程。直到资源获取然后该线程被唤醒。

参考：

https://blog.csdn.net/pange1991/article/details/80967701