多线程模式之Future模式

1 Future模式简介
当某一程序提交了一个请求，期望得到一个答复，但是这个请求需要处理的时间可能很长，传统模式下这个请求是同步的，客户端必须等待请求响应之后才能执行其他操作。而在Future模式下客户端立刻拿到一个伪造的数据(相当于商品的订单，而非商品本身)，而客户端在此期间可以调用其他业务逻辑，充分的利用了等待时间，这就是Future模式的核心所在。这样在整个调用过程中，就不存在无谓的等待，充分的利用了所有的时间片，从而提高了整体的响应速度。

如下图所示：




2.代码示例
Main:
public class Main {
    public static void main(String[] args){
        Client client = new Client();
        Data data = client.request("name");
        System.out.println("请求完毕");
        //这个相当于做了其他的业务操作，同时Future也在准备真实的数据，实现了并行，充分的利用了时间
        try{
            Thread.sleep(2000);
        }catch (InterruptedException e){}
        System.out.println("数据="+data.getResult());
    }
}


Client：
public class Client {
    public Data request(final String queryStr){
        final FutureData futureData = new FutureData();
        new Thread(){//构造真实数据，起了一个单独的线程，因为等待时间较长
            public void run(){
                RealData realData = new RealData(queryStr);
                futureData.setRealData(realData);
            }
        }.start();
        return futureData;
    }
}


Data:
public interface Data {
    public String getResult();
}


FututrData:

public class FutureData implements  Data {
    protected RealData realData = null;
    protected boolean isReady = false;
//Client中RealData准备好后，调用的此方法。
    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){
                e.printStackTrace();;
            }
        }
        return realData.result;
    }
}


RealData：

public class RealData implements Data {
    protected final String result;
    public RealData(String para){
        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;
    }
}


3 JDK内置实现
JDK内置实现了Future模式。

RealData:

public class RealData implements Callable {
    private String para;
    public RealData(String para){
        this.para = para;
    }
    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();
    }
}


Main:
public class Main {
    public static void main(String[] args) throws Exception{
        FutureTask<String> future = new FutureTask<String>(new RealData("a"));
        ExecutorService executor = Executors.newFixedThreadPool(1);
        executor.submit(future);
        System.out.println("请求完毕");
        try{
            Thread.sleep(2000);//其他业务操作
        }catch (InterruptedException e){}
        System.out.println("数据="+future.get());
    }
}



《Java性能优化》 葛一鸣