并发模型之Future设计模式

一、Futrue模式

客户端发送一个长时间的请求，服务端不需等待该数据处理完成便立即返回一个伪造的代理数据（相当于商品订单，不是商品本身），用户也无需等待，先去执行其他的若干操作后，再去调用服务器已经完成组装的真实数据。

该模型充分利用了等待的时间片段。简单来说就是，如果线程A要等待线程B的结果，那么线程A没必要等待B，直到B有结果，可以先拿到一个未来的Future，等B有结果是再取真实的结果。

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

二、Future模式的代码实现

1、创建公共数据接口

 package com.ietree.basicskill.mutilthread.designpattern;

 /**
  * Created by Root on 5/12/2017.
  */
 public interface Data {

     String getRequest();

 }

2、创建FutureData对象，当有程序想要获取RealData的时候，程序会被阻塞，等到RealData被注入才会使用getReal()方法

 package com.ietree.basicskill.mutilthread.designpattern;

 /**
  * Created by Root on 5/12/2017.
  */
 public class FutureData implements Data {

     private RealData realData;

     private boolean isReady = false;

     public synchronized void setRealData(RealData realData) {
         // 如果已经装载完毕了，就直接返回
         if (isReady) {
             return;
         }
         // 如果没装载，进行装载真实对象
         this.realData = realData;
         isReady = true;
         // 进行通知
         notify();
     }

     @Override
     public synchronized String getRequest() {
         // 如果没装载好，程序就一直处于阻塞状态
         while (!isReady) {
             try {
                 wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         // 装载好了直接获取数据即可
         return this.realData.getRequest();
     }
 }

3、真实数据RealData类

 package com.ietree.basicskill.mutilthread.designpattern;

 /**
  * Created by Root on 5/12/2017.
  */
 public class RealData implements Data {

     private String result;

     public RealData(String queryStr) {
         System.out.println("根据" + queryStr + "进行查询，这是一个很耗时间的操作......");
         try {
             Thread.sleep(5000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("操作完毕，获取结果");
         result = "查询结果";
     }

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

4、客户端代理类

 package com.ietree.basicskill.mutilthread.designpattern;

 /**
  * Created by Root on 5/12/2017.
  */
 public class FutureClient {

     public Data request(final String queryStr) {
         //1 我想要一个代理对象（Data接口的实现类）先返回给发送请求的客户端，告诉他请求已经接收到，可以做其他的事情
         final FutureData futureData = new FutureData();
         //2 启动一个新的线程，去加载真实的数据，传递给这个代理对象
         new Thread(new Runnable() {
             @Override
             public void run() {
                 //3 这个新的线程可以去慢慢的加载真实对象，然后传递给代理对象
                 RealData realData = new RealData(queryStr);
                 futureData.setRealData(realData);
             }
         }).start();

         return futureData;
     }

 }

5、测试调用

 package com.ietree.basicskill.mutilthread.designpattern;

 /**
  * Created by Root on 5/12/2017.
  */
 public class FutureTest {

     public static void main(String[] args) {
         FutureClient fc = new FutureClient();
         Data data = fc.request("请求参数");
         System.out.println("请求发送成功！");

         try {
             //处理其他业务
             //这个过程中，真实数据RealData组装完成，重复利用等待时间
             System.out.println("做其它的事情......");
             Thread.sleep(2000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }

         // 获取真实数据
         String result = data.getRequest();
         System.out.println(result);
     }

 }

程序运行结果：

请求发送成功！
做其它的事情......
根据请求参数进行查询，这是一个很耗时间的操作......
操作完毕，获取结果
查询结果

第二种写法（没有实际运用过）：

 package com.ietree.basicskill.mutilthread.designpattern;

 import java.util.ArrayList;
 import java.util.List;
 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;

 /**
  * Created by Root on 5/12/2017.
  */
 public class FutureTest2 {

     private static class Task implements Callable<String> {
         @Override
         public String call() throws Exception {
             // 模拟真实事务的处理过程，这个过程是非常耗时的。
             Thread.sleep(5000);
             return "call return ";
         }
     }

     public static void main(String[] args) throws InterruptedException, ExecutionException {

         List<Future<String>> futures = new ArrayList<Future<String>>();
         ExecutorService executorService = Executors.newCachedThreadPool();

         System.out.println("已经提交资源申请");
         for (int i = 0; i < 10; i++) {
             futures.add(executorService.submit(new Task()));
         }

         for (Future<String> future : futures) {
             // 判断资源是不是已经准备完毕，准备完毕直接获取。
             if (!future.isDone()) {
                 System.out.println("资源还没有准备好");
             }
             System.out.println(future.get());
         }
         executorService.shutdown();
     }
 }