Future模式 --先给你提货带

定义：

获取Future角色的线程会在稍后使用Future角色来获得运行的结果。

引例：

类的一览表

名字	说明
main	向host发出请求并获取数据
data	表示访问数据方法的接口。
host	向请求返回futuredata实例的类
futuredata	表示提货带类
realdata	表示真实数据

public class Main {
    public static void main(String[] args) {
        System.out.println("main BEGIN");
        Host host = new Host();
        Data data1 = host.request(10, 'A');
        Data data2 = host.request(20, 'B');
        Data data3 = host.request(30, 'C');

        System.out.println("main otherJob BEGIN");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
        }
        System.out.println("main otherJob END");

        System.out.println("data1 = " + data1.getContent());
        System.out.println("data2 = " + data2.getContent());
        System.out.println("data3 = " + data3.getContent());
        System.out.println("main END");
    }
}

public interface Data {
    public abstract String getContent();
}

public class FutureData implements Data {
    private RealData realdata = null;
    private boolean ready = false;
    public synchronized void setRealData(RealData realdata) {
        if (ready) {                        
            return;     // balk
        }
        this.realdata = realdata;
        this.ready = true;
        notifyAll();
    }
    public synchronized String getContent() {
        while (!ready) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        return realdata.getContent();
    }
}

public class RealData implements Data {
    private final String content;
    public RealData(int count, char c) {
        System.out.println("        making RealData(" + count + ", " + c + ") BEGIN");
        char[] buffer = new char[count];
        for (int i = 0; i < count; i++) {
            buffer[i] = c;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
        }
        System.out.println("        making RealData(" + count + ", " + c + ") END");
        this.content = new String(buffer);
    }
    public String getContent() {
        return content;
    }
}

public class Host {
    public Data request(final int count, final char c) {
        System.out.println("    request(" + count + ", " + c + ") BEGIN");

        // (1) 建立FutureData的实体
        final FutureData future = new FutureData();

        // (2) 为了建立RealData的实体，启动新的线程
        new Thread() {                                      
            public void run() {                             
                RealData realdata = new RealData(count, c);
                future.setRealData(realdata);
            }                                               
        }.start();                                          

        System.out.println("    request(" + count + ", " + c + ") END");

        // (3) 取回FutureData实体，作为传回值
        return future;
    }
}

 main BEGIN
    request(10, A) BEGIN
    request(10, A) END
    request(20, B) BEGIN
    request(20, B) END
    request(30, C) BEGIN
    request(30, C) END
main otherJob BEGIN
        making RealData(10, A) BEGIN
        making RealData(30, C) BEGIN
        making RealData(20, B) BEGIN
        making RealData(10, A) END
main otherJob END
data1 = AAAAAAAAAA
        making RealData(20, B) END
data2 = BBBBBBBBBBBBBBBBBBBB

Future模式出现的角色：

client（请求者）：client向host发出请求request，并立刻接收一个处理结果（虚拟数据）

host：host角色会创建新的线程，并开始在新的新的线程中创建realdara角色。

virtualdata（虚拟数据）：virtualdata角色是让future角色与realdata角色具有一致性的角色。

realdata（真实数据）：realdata角色表示真实的角色，创建该对象会花费很多时间。

future（期货）：future角色是“提货带”，由host角色传递给client角色。