Future 模式（异步调用）

在多线程交互的中2，经常有一个线程需要得到另个一线程的计算结果，我们常用的是Future异步模式来加以解决。
Future顾名思意，有点像期货市场的“期权”，是“对未来的一种凭证”，例如当我们买了某个房地产开发商的期房，交钱之后，开发商会给我们一个凭证（期权），这个凭证告诉我们等明年某个时候拿这个凭证就可以拿到我们所需要的房子，但是现在房子还没建好。市场上之所以有“期货”，也正由于有这种需求，才有这种供给。

这种应用在GUI上用的比较多，在设计模式中一般称为“虚拟代理模式”。

例如：现在有个这样的需求，Client向Server提交一个Request（int count,char c），希望获取一个由count个字符c构造出来的字符串。比如发送Request(10,'K')，那么反馈字符串“KKKKKKKKKK”，但是我们假设这个生成字符串的过程很费时间。

于是，为了获取比较好的交互性，我们的Server收到请求后，先构造一个FutureData，并把这个所谓的“期权（未来凭证）”反馈给Client；于此同时，通过另一个并发线程去构造一个真正的字符串RealData，并在构造完毕后，RealData给FutureData报告一个消息，说数据（期房）已经准备好了，此时Client可以通过期权拿到期房，但是假如我们的Client比较着急，还没等房子假好的时，就想要房子，怎么办呢？这个时候我们可以阻塞Client所在的线程，让Client等待，直到最后RealData通知FutureData说房子好了，才返回。

这里的要点：

（1）Server先给Client一个“期权”，同时开一个线程去干活建房子（未来的“现房”）；

（2）当“现房”RealData准备好了的时候，如何告诉FutureData说已经准备好了。（本处采用“回调过程”（借用观察者模式，来实现回调））

（3）如果客户比较着急，现房还没准备好的时候，就要取房，怎么办？ 本处采用“阻塞”。

Data（公共数据接口）

Java代码

1. packagecom.umpay.future;
3. publicinterfaceData{
4. publicabstractStringgetContent();
5. }

FutureData（期权）

Java代码

1. packagecom.umpay.future.extend;
3. importjava.util.Observable;
4. importjava.util.Observer;
6. importcom.umpay.future.Data;
8. publicclassFutureData2implementsData,Observer{
10. /**
11. *存放真实数据，并且标志真正的数据是否已经准备完毕
12. *被多线程享受
13. *如果realData2==null，表示数据还准备好
14. **/
15. privatevolatileRealData2realData2=null;
16. /**
17. *查看真正的数据是否准备完毕
18. **/
19. publicbooleanisFinished(){
20. returnrealData2!=null;
21. }
23. /**
24. *如果数据已经准备好，则返回真正的数据；
25. *否则，阻塞调用线程，直到数据准备完毕后，才返回真实数据；
26. **/
27. publicStringgetContent(){
28. synchronized(mutex){
29. while(!isFinished()){//只要数据没有准备完毕，就阻塞调用线程
30. try{
31. mutex.wait();
32. }catch(InterruptedExceptione){
33. e.printStackTrace();
34. }
35. }
36. returnrealData2.getContent();
37. }
38. }
40. /**
41. *当RealData2准备完数据后，RealData2应该通知FutureData2数据准备完毕。
42. *并在输入参数realData传入真实数据，在参数event传入事件（比如数据如期准备好了，或出了什么异常）
43. *
44. *@paramrealData真实的数据
45. *@paramevent事件类型
46. **/
47. publicvoidupdate(ObservablerealData,Objectevent){
48. System.out.println("通知...."+event);
49. if(!(realDatainstanceofRealData2)){
50. thrownewIllegalArgumentException("主题的数据类型必须是RealData2");
51. }
52. if(!(eventinstanceofString)){
53. thrownewIllegalArgumentException("事件的数据类型必须是String");
54. }
55. synchronized(mutex){
56. if(isFinished()){
57. mutex.notifyAll();
58. return;//如果数据已经准备好了，直接返回.
59. }
60. if("Finished".equals(event)){
61. realData2=(RealData2)realData;//数据准备好了的时候，便可以通知数据准备好了
62. mutex.notifyAll();//唤醒被阻塞的线程
63. }
64. }
65. }
67. privateObjectmutex=newObject();
68. }

RealData（实际数据）

Java代码

1. packagecom.umpay.future.extend;
3. importjava.util.Observable;
5. importcom.umpay.future.Data;
7. publicclassRealData2extendsObservableimplementsData{
9. privateStringcontent;
11. publicRealData2(){
13. }
15. publicvoidcreateRealData2(intcount,charc){
16. System.out.println("makingRealData("+count+","+c
17. +")BEGIN");
18. char[]buffer=newchar[count];
19. for(inti=0;i<count;i++){
20. buffer[i]=c;
21. try{
22. Thread.sleep(100);
23. }catch(InterruptedExceptione){
24. }
25. }
26. System.out.println("makingRealData("+count+","+c
27. +")END");
28. this.content=newString(buffer);
30. //真实数据准备完毕了，通知FutureData2说数据已经准备好了.
31. setChanged();//必须先设置本对象的状态发生了变化，并且通知所有的观察者
32. notifyObservers("Finished");
33. }
36. publicStringgetContent(){
37. returncontent;
38. }
39. }

服务端代码：

Java代码

1. packagecom.umpay.future.extend;
3. importcom.umpay.future.Data;
5. publicclassHostServer2{
7. publicDatarequest(finalintcount,finalcharc){
8. System.out.println("request("+count+","+c+")BEGIN");
10. //(1)建立FutureData的实体
11. finalFutureData2future2=newFutureData2();
13. //(2)为了建立RealData的实体，启动新的线程
14. newThread(){
15. publicvoidrun(){
16. RealData2realdata2=newRealData2();
17. realdata2.addObserver(future2);//以便当RealData2把数据准备完毕后，通过该回调口子，通知FutureData2表示数据已经贮备好了
18. realdata2.createRealData2(count,c);
19. }
20. }.start();
22. System.out.println("request("+count+","+c+")END");
24. //(3)取回FutureData实体，作为传回值
25. returnfuture2;
26. }
28. }

客户端代码：

Java代码

1. packagecom.umpay.future;
3. importcom.umpay.future.extend.HostServer2;
5. publicclassMainClient{
6. publicstaticvoidmain(String[]args){
7. //testHostServer();
8. testHostServer2();
9. }
11. staticvoidtestHostServer(){
12. System.out.println("mainBEGIN");
13. HostServerhostServer=newHostServer();
14. Datadata1=hostServer.request(10,'A');
15. Datadata2=hostServer.request(20,'B');
16. Datadata3=hostServer.request(30,'C');
18. System.out.println("mainotherJobBEGIN");
19. //try{
20. //Thread.sleep(2000);
21. //}catch(InterruptedExceptione){
22. //}
23. System.out.println("mainotherJobEND");
25. System.out.println("data1="+data1.getContent());
26. System.out.println("data2="+data2.getContent());
27. System.out.println("data3="+data3.getContent());
28. System.out.println("mainEND");
30. }
32. staticvoidtestHostServer2(){
33. System.out.println("mainBEGIN");
34. HostServer2hostServer2=newHostServer2();
35. Datadata1=hostServer2.request(10,'A');
36. Datadata2=hostServer2.request(20,'B');
37. Datadata3=hostServer2.request(30,'C');
39. System.out.println("mainotherJobBEGIN");
40. //try{
41. //Thread.sleep(2000);
42. //}catch(InterruptedExceptione){
43. //}
44. System.out.println("mainotherJobEND");
46. System.out.println("data1="+data1.getContent());
47. System.out.println("data2="+data2.getContent());
48. System.out.println("data3="+data3.getContent());
49. System.out.println("mainEND");
51. }
52. }