每天一例多线程[day15]----Future模式之美丽的谎言

Future模式的适用场景是：想要得到数据时，先返回数据的包装，异步获取真实数据，真正需要时再拿数据，真实数据也许已经异步得到，也许还在阻塞获取中...

       这有点像BOSS布置任务，比如由于市场需要，将在本月20号发布一个版本，今天是10号，分配任务给小弟去做了，询问小弟能不能搞定，由于小弟着急上位就答应了。而BOSS忙着处理每天的商务问题，在20号之前都没有空理会给小弟分配的任务。

    不知不觉时间到了20号，这时BOSS赶忙询问小弟做的到底如何了，其实这个时候小弟还差10%没有搞定，但是不想影响自己以后的信誉就回答已经搞定了，准备晚上部署，BOSS拍了拍小弟肩膀说“好样的！过一段给你加薪！”，BOSS走开后，小弟立刻拿出自己吃奶的力气，最终在晚上部署前完成了任务。

     思想就是发起请求后会立即返回一个数据给你，但是这个数据只是个包装，包装数据会异步请求真实数据，最终用的时候去拿真实的数据，可能异步加载完成直接返回，也可能未完成阻塞着。

     再比如情人节到了，女朋友问你准备礼物了没有，明明忘记了，但是依然说准备了，然后偷偷赶紧网购个，对吧！起码事情算是圆满了。

1. public interface Data {

2.  

3. String getRequest();

4.  

5. }

1. public class FutureData implements Data{

2.  

3. private RealData realData ;

4.  

5. private boolean isReady = false;

6.  

7. public Thread currentThread;

8.  

9. public synchronized void setRealData(RealData realData) {

10. //如果已经装载完毕了，就直接返回

11. if(isReady){

12. return;

13. }

14. //如果没装载，进行装载真实对象

15. this.realData = realData;

16. isReady = true;

17. //进行通知

18. notify();

19. }

20.  

21. @Override

22. public synchronized String getRequest() {

23. //如果没装载好 程序就一直处于阻塞状态

24. while(!isReady){

25. try {

26. wait();

27. } catch (InterruptedException e) {

28. e.printStackTrace();

29. }

30. }

31. //装载好直接获取数据即可

32. return this.realData.getRequest();

33. }

34.  

35. }

[java] view plain copy

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

1. public class FutureClient {

2.  

3. public FutureData request(final String queryStr){

4. //1 我想要一个代理对象（Data接口的实现类）先返回给发送请求的客户端，告诉他请求已经接收到，可以做其他的事情

5. final FutureData futureData = new FutureData();

6. //2 启动一个新的线程，去加载真实的数据，传递给这个代理对象

7. Thread t = new Thread(new Runnable() {

8. @Override

9. public void run() {

10. //3 这个新的线程可以去慢慢的加载真实对象，然后传递给代理对象

11. RealData realData = new RealData(queryStr);

12. futureData.setRealData(realData);

13. }

14. });

15. t.start();

16. futureData.currentThread = t;

17. return futureData;

18. }

19.  

20. }

 

1. public class Main {

2.  

3. public static void main(String[] args) throws InterruptedException {

4.  

5. FutureClient fc = new FutureClient();

6. FutureData data = fc.request("请求参数");

7. System.out.println("请求发送成功!");

8. System.out.println("做其他的事情..."+"请求数据线程状态："+data.currentThread.getState());

9. //经测试代码阻塞在这一行，等待获取真实数据，而 以上代码则实时执行

10. String result = data.getRequest();

11. System.out.println(result+"请求数据的线程状态："+data.currentThread.getState());

12.  

13. }

14.