13.多线程设计模式

多线程设计模式 - 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 + "毫秒");
      }
  }