Future模式

目录

Future模式的简单实现

JDK中的Future模式

---

Future模式的简单实现

1.定义返回数据的接口

public interface Data {
    public String getResult();
}

2.FutureData实现了一个快速返回的RealData包装。它只是一个RealData的虚拟实现。因此，它可以很快被构造并返回。当使用FutrueData的getResult()方法的时候,程序阻塞，直到RealData准备好并注入到FutureData中，才最终返回数据。FutureData是Future模式的关键，它实际上是真实数据RealData的代理，封装了获取RealData的等待过程。

public class FutureData implements Data {
    RealData realData = null; //FutureData是RealData的封装
    boolean isReady = false;  //是否已经准备好

    public synchronized void setRealData(RealData realData) {
        if(isReady)
            return;
        this.realData = realData;
        isReady = true;
        notifyAll(); //RealData已经被注入到FutureData中了，通知getResult()方法
    }

    @Override
    public synchronized String getResult() throws InterruptedException {
        if(!isReady) {
            wait(); //一直等到RealData注入到FutureData中
        }
        return realData.getResult();
    }
}

3.需要的真实数据，其构造比较慢。

public class RealData implements Data {
    protected String data;
    public RealData(String data) {
        //利用sleep方法来表示RealData构造过程是非常缓慢的
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.data = data;
    }

    @Override
    public String getResult() {
        return data;
    }
}

4.Client开启构造RealData的线程，立即返回FutureData

public class Client {
    public Data request(final String string) {
        final FutureData futureData = new FutureData();

        new Thread(new Runnable() {
            @Override
            public void run() {
                //RealData的构建很慢，所以放在单独的线程中运行
                RealData realData = new RealData(string);
                futureData.setRealData(realData);
            }
        }).start();
        return futureData; //先直接返回FutureData
    }
}

5.主函数Main主要负责调用Client发起请求，并消费返回的数据。

public static void main(String[] args) {
    Client client = new Client();
    Data data = client.request("name");
    System.out.println("请求完毕");
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {      
    }
    System.out.println("数据 = " + data.getResult());
}

JDK中的Future模式

//实现Collable接口，
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();
    }
}

public class FutureMain {
    public static void main(String[] args) throws InterruptedException, ExecutionException {

        FutureTask<String> future = new FutureTask<>(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());
    }
}