Java多线程编程中，常用的多线程设计模式包括：Future模式、Master-Worker模式、Guarded Suspeionsion模式、不变模式和生产者-消费者模式等。这篇文章主要讲述Future模式，关于其他多线程设计模式的地址如下：
关于Master-Worker模式的详解： 并行设计模式（二）-- Master-Worker模式
关于Guarded Suspeionsion模式的详解： 并行设计模式（三）-- Guarded Suspeionsion模式
关于不变模式的详解： 并行设计模式（四）-- 不变模式
关于生产者-消费者模式的详解：并行设计模式（五）-- 生产者-消费者模式
1. Future模式
Future模式的核心在于：去除了主函数的等待时间，并使得原本需要等待的时间段可以用于处理其他业务逻辑。
Future模式有点类似于商品订单。在网上购物时，提交订单后，在收货的这段时间里无需一直在家里等候，可以先干别的事情。类推到程序设计中时，当提交请求时，期望得到答复时，如果这个答复可能很慢。传统的是一直持续等待直到这个答复收到之后再去做别的事情，但如果利用Future模式，其调用方式改为异步，而原先等待返回的时间段，在主调用函数中，则可以用于处理其他事务。
例如如下的请求调用过程时序图。当call请求发出时，需要很长的时间才能返回。左边的图需要一直等待，等返回数据后才能继续其他操作；而右边的Future模式的图中客户端则无需等到可以做其他的事情。服务器段接收到请求后立即返回结果给客户端，这个结果并不是真实的结果（是虚拟的结果），也就是先获得一个假数据，然后执行其他操作。
Future模式的主要参与者如下表所示：
| 参 与 者 |
作 用 |
| Main | 系统启动，调用Client发出请求 |
| Client | 返回Data对象，立即返回FutureData，并开启ClientThread线程装配RealData |
| Data | 返回数据的接口 |
| FutureData | Future数据，构造很快，但是是一个虚拟的数据，需要装配RealData |
| RealData | 真实数据，其构造是比较慢的 |
2. Future模式的代码实现
应用实例对应模式结构图如下所示：
<1. Main函数的实现
Main函数主要负责调用Client发起请求，并使用返回的数据：
public class Main { public static void main(String[] args) { Client client = new Client(); // 这里会立即返回，因为获取的是FutureData，而非RealData Data data = client.request("name"); System.out.println("请求完毕"); try { // 这里可以用一个sleep代替对其他业务逻辑的处理 // 在处理这些业务逻辑过程中，RealData也正在创建，从而充分了利用等待时间 Thread.sleep(2000); // 使用真实数据 System.out.println("数据=" + data.getResult()); } catch (InterruptedException e) { e.printStackTrace(); } } }
<2. Client的实现
Client主要实现了获取futrueData，开启构造RealData的线程，并在接受请求后，很快地返回FutureData
public class Client { public Data request(final String string) { final FutureData futureData = new FutureData(); new Thread(new Runnable() { @Override public void run() { // RealData的构建很慢，所以放在单独的线程中运行 RealData realData = new RealData(string); futureData.setRealData(realData); } }).start(); return futureData; // 先直接返回FutureData } }
<3. Data的实现
Data是一个接口，提供了getResult()方法。无论futureData或者RealData都实现了这个接口
public interface Data { String getResult() throws InterruptedException; }
<4. FutureData的实现
FutureData实现了一个快速返回的RealData包装。它只是一个包装，或者说是一个RealData的虚拟实现。因此，它可以很快被构造并返回。当使用FutureData的getResult()方法是，程序会阻塞，等待RealData被注入到程序中，才使用RealData的getResult()方法返回。
1 public class FutureData implements Data { 2 RealData realData = null; // FutureData是RealData的封装 3 boolean isReady = false; // 是否已经准备好 4 5 public synchronized void setRealData(RealData realData) { 6 if (isReady) 7 return; 8 this.realData = realData; 9 isReady = true; 10 notifyAll(); // RealData已经被注入到FutureData中了，通知getResult()方法 11 } 12 13 @Override 14 public String getResult() throws InterruptedException { 15 if (!isReady) { 16 wait(); // 一直等到RealData注入到FutureData中 17 } 18 return realData.getResult(); 19 } 20 }
<5. RealData的实现
RealData是最终需要使用的数据模型，它的构造很慢。在这里，使用sleep()函数模拟这个过程
public class RealData implements Data { protected String data; public RealData(String data) { // 利用sleep方法来表示RealData构造过程是非常缓慢的 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } this.data = data; } @Override public String getResult() throws InterruptedException { return data; } }
3. JDK的内置Future模式实现
由于Future是非常常用的多线程设计模式，因此在JDK中内置了Future模式的实现。这些类在java.util.concurrent包里面。其中最为重要的是FutureTask类，它实现了Runnable接口，作为单独的线程运行。在其run()方法中，通过Sync内部类调用Callable接口，并维护Callable接口的返回对象。当使用FutureTask.get()方法时，将返回Callable接口的返回对象。其核心结构图如下所示：
JDK内置的Future模式功能强大，除了基本的功能外，它还可以取消Future任务，或者设定future任务的超时时间。Callable接口是一个用户自定义的实现。在应用程序中，通过实现Callable接口的call()方法，指定FutureTask的实际工作内容和返回对象。
Future接口提供的线程控制功能有：
1 boolean cancle(boolean mayInterruptIfRunning); // 取消任务 2 boolean isCancelled(); // 是否已经取消 3 boolean isDone(); // 是否已经完成 4 V get() throws InterruptedException, ExecutionException; //取得返回对象 5 V get(long timeout, TimeUnit unit); //取得返回对象，可以设置超时时间
同样，针对上述的实例，如果使用JDK自带的实现，则需要作一些调整。
首先，需要实现Callable接口，实现具体的业务逻辑。在本例中，依然使用RealData来实现这个接口：
1 public class RealData implements Callable<String> { 2 private String para; 3 4 public RealData(String para) { 5 this.para = para; 6 } 7 8 @Override 9 public String call() throws Exception { 10 // 利用sleep方法来表示真是业务是非常缓慢的 11 StringBuffer sb = new StringBuffer(); 12 for (int i = 0; i < 10; i++) { 13 sb.append(para); 14 try { 15 Thread.sleep(1000); 16 } catch (InterruptedException e) { 17 e.printStackTrace(); 18 } 19 } 20 return sb.toString(); 21 } 22 }
在这个改进中，RealData的构造变动非常快，因为其主要业务逻辑被移动到call()方法内，并通过call()方法返回。
Main方法修改如下，由于使用了JDK的内置框架，Data、FutureData等对象就不再需要了。在Main方法的实现中，直接通过RealData构造FutureTask，并将其作为单独的线程运行。在提交请求后，执行其他业务逻辑，最后通过FutureTask.get()方法，得到RealData的执行结果。
1 public class Main { 2 public static void main(String[] args) { 3 FutureTask<String> future = new FutureTask<String>(new RealData("liangyongxing")); 4 ExecutorService executor = Executors.newFixedThreadPool(1); // 使用线程池 5 //执行FutureTask，相当于上例中的client.request("name")发送请求 6 //在这里开启线程进行RealData的call()执行 7 executor.submit(future); 8 System.out.println("请求完毕"); 9 10 try { 11 // 这里仍然可以做额外的数据操作，这里使用sleep代替其他业务逻辑的处理 12 Thread.sleep(2000); 13 14 /** 15 * 相当于上例当中的 data.getResult()，取得call()方法的返回值 16 * 如果此时call()方法没有执行完毕，则依然会等待 17 */ 18 System.out.println("数据 = " + future.get()); 19 } catch (InterruptedException | ExecutionException e) { 20 e.printStackTrace(); 21 } finally {
executor.shutdown();
} 22 } 23 }