并发中的设计模式-Future

1.Future设计模式原理是客户端发送一个请求，处理器立即返回一个FutureData数据并且进行异步的获取真正的数据；在客户端真正需要用到实际数据的时候再去获取真正的数据；

原理图如下：

 

 

2.模拟实现future设计模式：

（1）定义Data接口

 1 public interface Data {
 2     
 3     /**
 4      * 返回真实数据
 5      *
 6      * @author yin.hl
 7      * @Title: getRealData 
 8      * @return
 9      * @return: String
10      */
11     public String getRealData();
12     
13 }

（2）RealData实现Data接口

 1 public class RealData implements Data {
 2 
 3     private String result;
 4 
 5     @Override
 6     public String getRealData() {
 7         return result;
 8     }
 9 
10     //根据参数初始化数据
11     public RealData initRealData(String param) {
12         System.out.println("根据" + param + "进行查询，这是一个很耗时的操作..");
13         try {
14             Thread.sleep(5000);
15         } catch (InterruptedException e) {
16             e.printStackTrace();
17         }
18         System.out.println("操作完毕，获取结果");
19         result = "查询结果";
20         return this;
21     }
22 
23 }

 

 

（3）FutureData实现Data接口，该接口中获取真正的数据

 1 public class FutureData implements Data {
 2 
 3     // 真实数据的引用
 4     private RealData realData;
 5     // 标记数据是否准备好了
 6     private boolean isReady = false;
 7 
 8     @Override
 9     public synchronized String getRealData() {
10         // 如果数据没准备好,则阻塞
11         if (!isReady) {
12             try {
13                 wait();
14             } catch (InterruptedException e) {
15                 e.printStackTrace();
16             }
17         }
18         // 返回真实数据,需要使用RealData的方法进行获取
19         return realData.getRealData();
20     }
21 
22     /**
23      *
24      * @author yin.hl
25      * @Title: initRealData
26      * @param param
27      * @return: void
28      */
29     public synchronized void initRealData(String param) {
30         // 如果数据已经准备完毕,就直接返回,释放对象锁
31         if (isReady) {
32             return;
33         }
34         // 如果数据没有准备完毕则使用参数初始化
35         realData = new RealData().initRealData(param);
36         isReady = true;
37         // 进行通知
38         notify();
39     }
40 
41 }

 

(4)处理器异步初始化真正的数据，并且返回FutureData

 1 public class FutureController {
 2 
 3     public FutureData handler(final String param){
 4         //由于真实的数据还没有准备好,所以返回一个真实Data数据的代理类
 5         final FutureData futureData = new FutureData();
 6         
 7         //2 启动一个新的线程，去加载真实的数据，传递给这个代理对象
 8         new Thread(new Runnable() {
 9             @Override
10             public void run() {
11                 futureData.initRealData(param);
12             }
13         }).start();
14         
15         return futureData;
16     }
17 }

 

（5）客户端发送请求获取数据

 1 public class Main {
 2 
 3     public static void main(String[] args) throws InterruptedException {
 4         
 5         //1.客户端发送请求,此处的客户端就是Main方法
 6         FutureController fc = new FutureController();
 7         //2.服务端的Controller.handler方法被调用,并传入了参数
 8         //3.此处返回的Data对象为FutureData对象,返回的是Data的代理类
 9         FutureData data = fc.handler("UserId");
10         System.out.println("请求发送成功...");
11         System.out.println("继续其他的处理...");
12         
13         //3.获取真实数据
14         System.out.println("Main开始获取真实结果");
15         String result = data.getRealData();
16         System.out.println(result);
17     }
18 }

 

转载于:https://www.cnblogs.com/xuzhiyuan/p/9267188.html