Java多线程技术研究（四）-Callable，Future/FutureTask，及Future设计模式

本篇博客Java多线程中另一块重要的内容：Callable，Future，FutureTask，及Future设计模式的模拟实现。

考虑这样一种场景： 网上购物，提交订单后，在收货的这段时间里无需一直在家里等候，可以先干别的事情。类推到程序设计中时，当提交请求时，期望得到答复时，如果这个答复可能很慢。传统的做法一直等待直到收到应答，可能才会去做后续的事情。在Java中提供Callable和Future机制实现了异步调用，即主线程为得到某个答复，创建一个子线程等待该答复，然后主线程在这个过程中干其他事情，办完其它事情后再去获得答复。我们把这种设计称为Future设计模式。

1、Callable和Runnable

在Java多线程技术研究（一） 中，Callable和Runnable一样，都是实现多线程的一种方法，但是Runnable不会返回结果，并且无法抛出带返回结果的异常，而Callable功能更加强大一些，线程执行结束后可以返回结果。这个结果可以通过Future或FutureTask拿到该线程的返回值。

Callable接口call()方法返回值为泛型，可以返回执行结果，并且还可以抛出异常：

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接口run()方法返回值为void型，显然不可获得其执行结果

public
interface Runnable {
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the object's
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see     java.lang.Thread#run()
*/
public abstract void run();
}

2、Callable和Future获取线程执行结果

Future接口中定义有如下方法：

1）cancel()

boolean cancel(boolean mayInterruptIfRunning);

取消任务的执行，mayInterruptRunning参数表示是否中断执行中的线程。

2）isCancelled()

boolean isCancelled();

任务是否已取消，如果在正常完成前已取消返回true。

3）isDone()

boolean isDone();

任务是否已完成，不管该任务是正常停止，异常导致，主动终止，均返回true。

4）get()

V get() throws InterruptedException, ExecutionException;

获取异步执行的结果，如果任务没有执行结束，此方法会阻塞直到任务完成。

5） get(long timeout, TimeUnit unit)

V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;

其中timeout为超时时间，unit为时间单位，如果在阻塞timeout时间，仍没有获得返回结果，get()方法会抛出TimeoutException异常。

下面来看利用Callable和Future获取线程执行结果

package com.wygu.thread.study;

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

public class MultiThreadCallable {
public static void main(String []argv){
TaskCallable tCallable = new TaskCallable();
ExecutorService executorService = Executors.newSingleThreadExecutor();
//将任务提交到线程池中
Future<Integer> future =executorService.submit(tCallable);
//主线程可以进行其他事情
try {
Integer result = future.get();
System.out.println("子线程返回结果为："+result);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}

}

class TaskCallable implements Callable<Integer>{
@Override
public Integer call(){
int num=10;
try {
Thread.sleep(3000);
num+=10;
} catch (InterruptedException e) {
e.printStackTrace();
}
return num;
}
}

子线程返回结果为：20

3、Callable和FutureTask

首先看一下类FutureTask的实现：

public class FutureTask<V> implements RunnableFuture<V>

FutureTask实现了接口RunnableFuture，而对于RunnableFuture的实现：

public interface RunnableFuture<V> extends Runnable, Future<V>

RunnableFuture不仅实现了Future中的方法，还实现了Runnable中run方法。

因而FutureTask不仅可以直接提交给Executor执行，还可以调用线程直接执行FutureTask中实现的run()方法.

通过FutureTask的下述两种构造方法，利用FutureTask可以获得Runnable的中执行结果。

public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW;       // ensure visibility of callable
}
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW;       // ensure visibility of callable
}

下面来看利用Callable和FutureTask获取线程执行结果

public class MultiThreadCallable {
public static void main(String []argv){
TaskCallable tCallable = new TaskCallable();
FutureTask<Integer> futureTask = new FutureTask<Integer>(tCallable);
new Thread(futureTask,"带返回值的线程").start();
//主线程可以进行其他事情
try {
Integer result = futureTask.get();
System.out.println("子线程返回结果为："+result);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}

}

class TaskCallable implements Callable<Integer>{
@Override
public Integer call(){
int num=10;
try {
Thread.sleep(3000);
num+=10;
} catch (InterruptedException e) {
e.printStackTrace();
}
return num;
}
}

程序执行结果：

子线程返回结果为：20

4、Future设计模式的模拟实现

在前面的场景中：网上挑好物品后，提交表单会获得一个订单，然后就可以等待收货，在收货的这段时间里无需一直在家里等候，可以先干别的事情。



图片来源于：http://blog.csdn.net/ghuil/article/details/41048017

在传统多线程模式，采用的是同步调用方式，Client发出call请求后，会一直等待服务端给予真实的应答数据，只有当Client等待到应答后，才能进行其它事情。而在Future设计模式调用中，Client发出call请求后，Server端会立即给予Client端一个应答，此时的应答数据可以说是一个假数据（不是真实的结果），Client端收到Server端的应答后，就去处理其它事情了，而Server端内部可以慢慢的生产数据，完成后把放置在对象中，等待Client端获取。

下面给出Future模式的程序实现

1）FutureClient的实现

FutureClient主要功能包括：获得假数据FutureData，获得真实数据RealData

package com.wygu.futurePattern;

public class FutureClient<T> {
private T requestData = null;

public FutureClient(T requestdata){
this.requestData = requestdata;
}
//创建方法，获得真实的数据
public FutureData<T> callForBack(){
final FutureData<T> fData = new FutureData<T>();

new Thread(new Runnable() {

@Override
public void run() {
RealData<T> realData = new RealData<T>(requestData);
fData.setRealData(realData);

}
}).start();
return fData;
}
}

2）Data的实现

接口Data中，定义一个获得数据的方法getResult()，在FutureData，RealData均重新实现该接口。其中FutureData可以说是对RealData的代理，它会封装RealData的getResult()方法。

Data接口定义

package com.wygu.futurePattern;

public interface Data<T> {
public T getResult()  throws InterruptedException;
}

FutureData的实现

package com.wygu.futurePattern;

public class FutureData<T> implements Data<T>{
private RealData<T> realData = null;
private volatile boolean isReady = false;

public synchronized void setRealData(RealData<T> realData) {
//判断真实数据是否已完成
if(isReady){
return;
}
this.realData = realData;
//数据已生产好
this.isReady = true;
//唤醒等待的线程
notifyAll();

}

@Override
public synchronized T getResult() throws InterruptedException {
if(!isReady){
wait();//阻塞调用该方法的线程，产生真实的数据
}
return realData.getResult();
}

}

RealData的实现

package com.wygu.futurePattern;

@SuppressWarnings("rawtypes")
public class RealData<T> implements Data{
private T realData = null;

public RealData(T realData) {
//使用sleep模拟生产真实数据很慢
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.realData = realData;
}

@Override
public T  getResult() throws InterruptedException{
//获取生产的真实数据
return realData;
}

}

3）测试运行

package com.wygu.futurePattern;

public class Main {

public static void main(String[] args) {
long start = System.currentTimeMillis();
FutureClient<String> futureClient = new FutureClient<String>("Hi,Future Pattern");
//主线程创建Client实例，去请求真实数据
FutureData<String> futureData = futureClient.callForBack();
//让主线程沉睡一段时间，在去获得真实数据
try {
Thread.sleep(9000);
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
System.out.println("Client 获取真实数据："+futureData.getResult()+",共耗时："+(System.currentTimeMillis()-start)+"毫秒");
} catch (InterruptedException e) {
e.printStackTrace();
}

}

}

运行结果为：Client 获取真实数据：Hi,Future Pattern,共耗时：9997毫秒

修改主线程做其他工作时间（沉睡时间）为Thread.sleep(11000)，运行结果为：Client 获取真实数据：Hi,Future Pattern,共耗时：10994毫秒。假设主线程的处理其它事物的时间为t1，Server端产生真实数据的时间为t2，则主线程运行结束的时间为max（t1,t2）.