解析Java語言中如何使用Future類的方法

public interface Data {
    public String getResult ();
}

public class FutureData implements Data {
    // 內部需要維護RealData
    protected RealData realdata = null;          
    protected boolean isReady = false;
    public synchronized void setRealData(RealData realdata) {
        if (isReady) { 
            return;
        }
        this.realdata = realdata;
        isReady = true;
        //RealData已經(jīng)被注入，通知getResult()
        notifyAll();                            			
    }
    //會等待RealData構造完成
    public synchronized String getResult() {        	
        while (!isReady) {
            try {
                //一直等待，直到RealData被注入
                wait();                        			
            } catch (InterruptedException e) {
            }
        }
        //真正需要的數(shù)據(jù)從RealData獲取
        return realdata.result;                    		
    }
}

public class Client {
    //這是一個異步方法，返回的Data接口是一個Future
    public Data request(final String queryStr) {
        final FutureData future = new FutureData();
        new Thread() {                                      
            public void run() {                    	
                // RealData的構建很慢，所以在單獨的線程中進行
                RealData realdata = new RealData(queryStr);
                //setRealData()的時候會notify()等待在這個future上的對象
                future.setRealData(realdata);
            }                                               
        }.start();
        // FutureData會被立即返回，不會等待RealData被構造完
        return future;                        		
    }
}

public static void main(String[] args) {
    Client client = new Client();
    //這里會立即返回，因為得到的是FutureData而不是RealData
    Data data = client.request("name");
    System.out.println("請求完畢");
    try {
        //這里可以用一個sleep代替了對其他業(yè)務邏輯的處理
        //在處理這些業(yè)務邏輯的過程中，RealData被創(chuàng)建，從而充分利用了等待時間
        Thread.sleep(2000);
    } catch (InterruptedException e) {
    }
    //使用真實的數(shù)據(jù)，如果到這里數(shù)據(jù)還沒有準備好，getResult()會等待數(shù)據(jù)準備完，再返回
    System.out.println("數(shù)據(jù) = " + data.getResult());
}

        //異步操作 可以用一個線程池
        ExecutorService executor = Executors.newFixedThreadPool(1);
        //執(zhí)行FutureTask，相當于上例中的 client.request("name") 發(fā)送請求
        //在這里開啟線程進行RealData的call()執(zhí)行
        Future<String> future = executor.submit(new RealData("name"));
        System.out.println("請求完畢，數(shù)據(jù)準備中");
        try {
            //這里依然可以做額外的數(shù)據(jù)操作，這里使用sleep代替其他業(yè)務邏輯的處理
            Thread.sleep(2000);
        } catch (InterruptedException e) {
        }
        //如果此時call()方法沒有執(zhí)行完成，則依然會等待
        System.out.println("數(shù)據(jù) = " + future.get());

    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        // 根據(jù)Callable對象，創(chuàng)建一個RunnableFuture，這里其實就是FutureTask
        RunnableFuture<T> ftask = newTaskFor(task);
        //將ftask推送到線程池
        //在新線程中執(zhí)行的，就是run()方法，在下面的代碼中有給出
        execute(ftask);
        //返回這個Future，將來通過這個Future就可以得到執(zhí)行的結果
        return ftask;
    }
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }

    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        //如果沒有完成，就等待，回到用park()方法阻塞線程
        //同時，所有等待線程會在FutureTask的waiters字段中排隊等待
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }
    private V report(int s) throws ExecutionException {
        //outcome里保存的就是最終的計算結果
        Object x = outcome;
        if (s == NORMAL)
            //正常完成，就返回outcome
            return (V)x;
        //如果沒有正常完成， 比如被用戶取消了，或者有異常了，就拋出異常
        if (s >= CANCELLED)
            throw new CancellationException();
        throw new ExecutionException((Throwable)x);
    }

        public void run() {
            CompletableFuture<T> d; Supplier<T> f;
            if ((d = dep) != null && (f = fn) != null) {
                dep = null; fn = null;
                if (d.result == null) {
                    try {
                        //這里就是你要執(zhí)行的異步方法
                        //結果會被保存下來，放到d.result字段中
                        d.completeValue(f.get());
                    } catch (Throwable ex) {
                        d.completeThrowable(ex);
                    }
                }
                //執(zhí)行成功了，進行后續(xù)處理，在這個后續(xù)處理中，就會調用thenAccept()中的消費者
                //這里就相當于Future完成后的通知
                d.postComplete();
            }
        }

   final void postComplete() {
                //省略部分代碼，重點在tryFire()里
                //在tryFire()里，真正觸發(fā)了后續(xù)的調用，也就是thenAccept()中的部分
                f = (d = h.tryFire(NESTED)) == null ? this : d;
            }
        }
    }