future模式

public class {
   
    public Data request(T t){
        ...
    }
}

public class Data{
    public T getResult();
}

public class FutureData implements Data{
    private RealData realData;
    private boolean ready;
    // 
    public synchronized T getResult(){
        if(!ready)
        {
            try {
                wait();
            }catch(InterruptException e) {
                ....
            }
        }
        return realData.result;
    }
    
    public synchronized void setResult(RealData realData) {
        if(ready) {
            return;
        }
        this.realData = realData;
        ready = true;
        notifyAll();
    }
}

public void run() {
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
                result = c.call();
                ran = true;
            } catch (Throwable ex) {
                result = null;
                ran = false;
                setException(ex);
            }
            if (ran)
                set(result);
        }
    } finally {
        // runner must be non-null until state is settled to
        // prevent concurrent calls to run()
        runner = null;
        // state must be re-read after nulling runner to prevent
        // leaked interrupts
        int s = state;
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    return report(s);
}