java并发包：future模式

叁歲伎倆 2024-02-17 21:18 78阅读 0赞

本文转载至：http://blog.csdn.net/a910626/article/details/51900972

future模式是多线程开发中非常常见的一种设计模式，它的核心思想是异步调用。当我们需要调用一个函数方法时，如果这个函数执行很慢，那么我们就要进行等待。但有时候我们可能并不着急着要结果。因此，我们可以让被调用者立即返回，让他在后台慢慢处理这个请求。对于调用者来说，则可以先处理一些其他任务，在真正需要数据的场合再去尝试获得需要的数据。

Future模式有点类似于商品订单。在网上购物时，提交订单后，在收货的这段时间里无需一直在家里等候，可以先干别的事情。类推到程序设计中时，当提交请求时，期望得到答复时，如果这个答复可能很慢。传统的时一直等待到这个答复收到时再去做别的事情，但如果利用Future设计模式就无需等待答复的到来，在等待答复的过程中可以干其他事情。

对于future模式来说，虽然它无法立即给你需要的数据。但是，它会返回给你一个契约，将来，你可以凭借这个契约去重新获取你需要的信息。

## Future模式java实现 ##

![futurejava.png][]

(1) Data.[Java][]

public interface Data {
        public String getResult();
    }
     
     
      
       1 
       2 
       3 
      
     
     
      
       1 
       2 
       3

(2) RealData.java

public class RealData implements Data {
        
        protected final String result;
        public RealData(String para) {
            //RealData的构造可能很慢，需要用户等待很久
            StringBuffer sb=new StringBuffer();
            for (int i = 0; i < 10; i++) {
                sb.append(para);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                }
            }
            result=sb.toString();
        }
        public String getResult() {
            return result;
        }
    }
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
      
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18

(3) FutureData.java

public class FutureData implements Data {
        
        protected RealData realdata = null;
        protected boolean isReady = false;
        public synchronized void setRealData(RealData realdata) {
            if (isReady) {                        
                return;     
            }
            this.realdata = realdata;
            isReady = true;
            notifyAll();
        }
        public synchronized String getResult() {
            while (!isReady) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
            return realdata.result;
        }
    }
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
      
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21

(4) Client.java

public class Client {
        
        public Data request(final String queryStr) {
            final FutureData future = new FutureData();
            // RealData的构建很慢
            new Thread() {                                      
                public void run() {                             
                    RealData realdata = new RealData(queryStr);
                    future.setRealData(realdata);
                }                                               
            }.start();
            return future;
        }
    }
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
      
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13

(5) Main.java

public class Main {
        public static void main(String[] args) {
            Client client = new Client();
    
            Data data = client.request("a");
            System.out.println("请求完毕");
            try {
                //这里可以用一个sleep代替了对其它业务逻辑的处理
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
                //使用真实的数据
            System.out.println("数据 = " + data.getResult());
        }
    }
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
      
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15

输出结果：  
请求完毕  
数据 = aaaaaaaaaa

## future jdk实现 ##

![futurejdk.png][]

(1) RealData.java

import java.util.concurrent.Callable;
    
    public class RealData implements Callable<String> {
        
        private String para;
        public RealData(String para){
            this.para=para;
        }
        @Override
        public String call() throws Exception {
    
            StringBuffer sb=new StringBuffer();
            for (int i = 0; i < 10; i++) {
                sb.append(para);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                }
            }
            return sb.toString();
        }
    }
    
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
       22 
      
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
       22

(2) Main.java

import java.util.concurrent.ExecutionException;
    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 InterruptedException, ExecutionException {
            //构造FutureTask
            FutureTask<String> future = new FutureTask<String>(new RealData("a"));
            ExecutorService executor = Executors.newFixedThreadPool(1);
            //执行FutureTask，相当于上例中的 client.request("a") 发送请求
            //在这里开启线程进行RealData的call()执行
            executor.submit(future);
            System.out.println("请求完毕");
            try {
            //这里依然可以做额外的数据操作，这里使用sleep代替其他业务逻辑的处理
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            //相当于上例中得data.getContent()，取得call()方法的返回值
            //如果此时call()方法没有执行完成，则依然会等待
            System.out.println("数据 = " + future.get());
        }
    }
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
       22 
       23 
       24 
      
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
       22 
       23 
       24

输出结果：  
请求完毕  
数据 = aaaaaaaaaa

[futurejava.png]: http://7xvzr8.com1.z0.glb.clouddn.com/futurejava.png
[Java]: http://lib.csdn.net/base/javase
[futurejdk.png]: http://7xvzr8.com1.z0.glb.clouddn.com/futurejdk.png