多线程的设计模式

　　并行设计模式属于设计优化的一部分，它是对一些常用的多线程结构的总结和抽象。与串行程序相比，并行结构的程序通常更为复杂。因此合理的使用并行模式在多线程开发中更具有意义，在这里主要介绍future、master-woeker和生产者-消费者模型。

　　future模式有点类似于商品订单。比如在网购时，当看中某件商品时，就可以提交订单，当订单处理完成后，在家里等待商品送货上门即可。或者说更形象的我们发送Ajax请求的时候，页面是异步的进行后台处理，用户无需一直等待用户请求的结果，可以继续浏览或操作其他内容。

基本思路：在client请求数据的时候，futureData先给一个空壳给客户端，然后futureData启动一个线程，什么时候将数据加载完成，Client才能使用这个数据，在futureData启动的线程中获取真实数据，真正的操作数据是在realData中获取，然后将数据依次传回来。（在这其中，用到了线程的阻塞）

代码：

Main：

 1 package com.java.day04_mode_future;
 2
 3 public class Main {
 4
 5     public static void main(String[] args) {
 6         FutureClient fc = new FutureClient();
 7         Data data = fc.request("请求参数");
 8
 9         System.out.println("请求发送成功");
10         System.out.println("做其他的事情。。。。");
11
12         String result  = data.getRequest();
13         System.out.println(result);
14
15
16     }
17
18 }

FutureClient：

 1 package com.java.day04_mode_future;
 2
 3 public class FutureClient {
 4     public Data request(final String queryStr){
 5         //1.我想要一个代理对象（Data接口的实现类），先返回给发送请求的客户端，告诉他请求已经收到，可以做其他事情
 6         final FutureData futureData = new FutureData();
 7
 8         //2.启动一个新的线程，去加载真实数据，传递给代理对象
 9         new Thread(new Runnable() {
10             public void run() {
11                 //这个线程可以慢慢加载真实对象，然后传递给代理对象
12                 RealData data = new RealData(queryStr);
13                 futureData.setRealData(data);
14
15             }
16         }).start();
17
18         return futureData;
19     }
20 }

FutureData：

 1 package com.java.day04_mode_future;
 2
 3 public class FutureData implements Data{
 4
 5
 6     private RealData realData;
 7
 8     private boolean isReady=false;
 9
10     public synchronized void setRealData(RealData realData){
11         //如果真实数据已经装载好，则直接返回
12         if(isReady){
13             return;
14         }
15
16         this.realData=realData;
17         isReady=true;
18         //进行通知
19         notify();
20     }
21
22
23     @Override
24     public synchronized String getRequest() {
25         //如果还没有装载好，则进入阻塞状态
26         while(!isReady){
27             try {
28                 wait();
29             } catch (InterruptedException e) {
30                 e.printStackTrace();
31             }
32         }
33         //返回真实数据
34         return this.realData.getRequest();
35     }
36
37
38
39
40
41 }

RealData

 1 package com.java.day04_mode_future;
 2
 3 public class RealData implements Data{
 4
 5     public String result;
 6
 7     public RealData(String queryStr){
 8         System.out.println("根据"+queryStr+"进行查询，这是一个很耗时的操作。。。");
 9         try {
10             Thread.sleep(1000);
11         } catch (InterruptedException e) {
12             e.printStackTrace();
13         }
14
15         System.out.println("操作完毕，获取结果");
16         result="得到结果";
17
18
19     }
20
21     @Override
22     public String getRequest() {
23         return result;
24     }
25
26 }

Data：

1 package com.java.day04_mode_future;
2
3 public interface Data {
4     String getRequest();
5 }

运行结果：

1 请求发送成功
2 做其他的事情。。。。
3 根据请求参数进行查询，这是一个很耗时的操作。。。
4 操作完毕，获取结果
5 得到结果

其实这个模式java已经实现，我们可以直接使用。