Java의 미래 패턴

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(callable);    //主线程需要callable线程的结果，先拿到一个未来的FutureSystem.out.println(future.get());    //有了结果后再根据get方法取真实的结果,当然如果此时callable线程如果没有执行完get方法会阻塞执行完，如果执行完则直接返回结果或抛出异常

 1 package com.future; 2  3 /** 4  * 结果的真实计算过程 5  * Created by yulinfeng on 6/18/17. 6  */ 7 public class RealData implements Data { 8     protected String data; 9 10     public RealData(String data) {11         try {12             System.out.println("正在计算结果");13             Thread.sleep(3000);     //模拟计算14         } catch (InterruptedException e) {15             e.printStackTrace();16         }17         this.data = data + “ world”;18     }19 20     public String getResult() throws InterruptedException {21         return data;22     }23 }

 1 package com.future; 2  3 /** 4  * 真实结果RealData的代理 5  * Created by yulinfeng on 6/18/17. 6  */ 7 public class FutureData implements Data { 8     RealData realData = null;   //对RealData的封装，代理了RealData 9     boolean isReady = false;    //真实结果是否已经准备好10 11     public synchronized void setResultData(RealData realData) {12         if (isReady) {13             return;14         }15         this.realData = realData;16         isReady = true;17         notifyAll();    //realData已经被注入到了futureData中，通知getResult方法18     }19 20     public synchronized String getResult() throws InterruptedException {21         if (!isReady) {22             wait();     //数据还未计算好，阻塞等待23         }24         return realData.getResult();25     }26 }

 1 package com.future; 2  3 /** 4  * Client主要完成的功能包括：1. 返回一个FutureData；2.开启一个线程用于构造RealData 5  * Created by yulinfeng on 6/18/17. 6  */ 7 public class Client { 8  9     public Data request(final String string) {10         final FutureData futureData = new FutureData();11 12         /*计算过程比较慢，单独放到一个线程中去*/13         new Thread(new Runnable() {14 15             public void run() {16                 RealData realData = new RealData(string);17                 futureData.setResultData(realData);18             }19         }).start();20 21         return futureData;  //先返回一个“假”的futureData22     }23 }

 1 /** 2  * 负责调用Client发起请求，并使用返回的数据。 3  * Created by yulinfeng on 6/18/17. 4  */ 5 public class Main { 6     public static void main(String[] args) throws InterruptedException { 7         Client client = new Client(); 8         System.out.println("准备计算结果"); 9         Data data = client.request("hello");    //立即返回一个“假”的futureData，可以不用阻塞的等待数据返回，转而执行其它任务10         System.out.println("执行其它任务");11         Thread.sleep(3000);     //模拟执行其它任务12         System.out.println("数据的计算结果为：" + data.getResult());13     }14 }

 1 package com.future; 2  3 import java.util.concurrent.Callable; 4  5 /** 6  * 结果的真实计算过程 7  * Created by yulinfeng on 6/18/17. 8  */ 9 public class RealData2 implements Callable<String> {10     protected String data;11 12     public RealData2(String data) {13         this.data = data;14     }15     public String call() throws Exception {16         try {17             System.out.println("正在计算结果");18             Thread.sleep(2000);     //模拟计算结果19         } catch (InterruptedException e) {20             e.printStackTrace();21         }22         this.data = data + " world";23         return data;24     }25 }

 1 package com.future; 2  3 import java.util.concurrent.ExecutionException; 4 import java.util.concurrent.ExecutorService; 5 import java.util.concurrent.Executors; 6 import java.util.concurrent.Future; 7  8 /** 9  * 负责调用Executor的submit，并使用返回的数据。10  * Created by yulinfeng on 6/18/17.11  */12 public class Main2 {13 14     public static void main(String[] args) throws InterruptedException, ExecutionException {15         ExecutorService client = Executors.newSingleThreadExecutor();   //类似Client16         System.out.println("准备计算结果");17         Future<String> data = client.submit(new RealData2("hello"));    //类似Client.request18         System.out.println("执行其它任务");19         Thread.sleep(3000);20         System.out.println("数据的计算结果为：" + data.get());21     }22 }