13.多线程设计模式 - Future模式

多线程设计模式 - Future模式

并发设计模式属于设计优化的一部分，它对于一些常用的多线程结构的总结和抽象。与串行相比并行程序结构通常较为复杂，因此合理的使用并行模式在多线程并发中更具有意义。

1. Future

Future模式是多线程开发中非常常见的一种设计模式，它的核心思想是异步调用。

这类似我们日常生活中的在线购物流程，带在购物网看着一件商品时可以提交表单，当订单完成后就可以在家里等待商品送货上门。

或者说更形象的是我们发送Ajax请求的时候，页面是异步的进行后台处理，用户无需等待请求的结果，可以继续浏览或操作其他内容

示例：下面示例为Future的原理实现；<br />
说明：看类注释即可明了 不明白可以去屎

 //Data.java   * 首先看这个接口Data,只有一个方法getRequest(),返回String字符串.
   public interface Data {
       String getRequest();
   }
   //RealData.java   * 然后再看RealData这个类,实现了Data接口,首先他有构造函数,可以理解为一个真实的业务逻辑，比较耗时,做这个sleep我们可以想象成在处理业务逻辑.
   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;
       }
   }

   //FutureData.java* 接着再看FutureData这个类,也实现了Data接口.先看FutureData的getRequest()方法,这个方法先死循环判断boolean,如果isReady是true,就阻塞着,不然就返回RealData真的getRequest()\\\方法(真实的结果).
   //  然后再看setRealData(),判断isReady,如果是ture,直接return,如果不是就赋值RealData,并修改isReady,然后notify()..
   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();
       }
   }
   //FutureClient.java * 最后看FutureClient 这个类,最简单了,返回futureData,偷偷开了线程,看到RealData realData = new RealData(request)没有?就是开始执行业务了,然后当FutureData这个类的setRealData(RealData realData)时就通知了..
   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();
           //直接返回一个假的包装类futureData
           return futureData;
       }
   }
   //主函数
   public class Main {

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

         String result = data.getRequest();
         System.out.println(result);
     }
   }

上面的原理你可以不用懂,当然懂最好了,可以在面试官面前吹牛逼啊..future模式这么凶残,jdk也有实现的,在java.util.concurrent,又是concurrent,这个工具类真的是强大<br />
示例：<br />

 //
   import java.util.concurrent.Callable;

   public class RealData implements Callable<String> {
     private String Data;

     public RealData(String Data) {
         this.Data = Data;
     }

     public String call() throws Exception {
         //利用sleep来表示任务处理
         Thread.sleep(2000);

         return "这是处理"+Data+"结果";
     }
   }
   //
   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;
   import java.util.concurrent.FutureTask;

   public class Main {

       public static void main(String[] args) throws Exception {
           Long start = System.currentTimeMillis();

           FutureTask<String> futureTask = new FutureTask<>(new RealData("hello,world"));
           ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(1);
           newFixedThreadPool.submit(futureTask);

           // 表示正在处理其他逻辑,或者业务
           Thread.sleep(1000);

           System.out.println("最后结果-->" + futureTask.get());

           Long end = System.currentTimeMillis();

           Long useTime = end - start;

           System.out.println("程序运行了-->" + useTime + "毫秒");
       }
   }