程式碼要解決的問題是：在兩個執行緒裡並行執行任務A和任務B，只要有一個任務完成了，就執行任務C。程式碼如下：

import java.time.LocalTime;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class LearnCompleteFuture {
	
	private static Random random = new Random();

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		useFuture();
		
		TimeUnit.SECONDS.sleep(10);
		System.out.println();
		
		useCompletableFuture();
	}

	private static void useFuture() throws InterruptedException, ExecutionException {
		System.out.println("Future");
		ExecutorService exector = Executors.newFixedThreadPool(3);
		Future<Void> futureA = exector.submit(() -> work("A1"));
		Future<Void> futureB = exector.submit(() -> work("B1"));
		while (true) {
			try {
				futureA.get(1, TimeUnit.SECONDS);
				break;
			} catch (TimeoutException e) {
			}
			try {
				futureB.get(1, TimeUnit.SECONDS);
				break;
			} catch (TimeoutException e) {
			}
		}
		exector.submit(() -> work("C1")).get();
		exector.shutdown();
	}
	
	private static void useCompletableFuture() throws InterruptedException, ExecutionException {
		System.out.println("CompletableFuture");
		CompletableFuture<Void> futureA = CompletableFuture.runAsync(() -> work("A2"));
		CompletableFuture<Void> futureB = CompletableFuture.runAsync(() -> work("B2"));
		futureA.runAfterEither(futureB, () -> work("C2")).get();
	}

	public static Void work(String name) {
		System.out.println(name + " starts at " + LocalTime.now());
		try {
			TimeUnit.SECONDS.sleep(random.nextInt(10));
		} catch (InterruptedException e) {
		}
		System.out.println(name + " ends at " + LocalTime.now());
		return null;
	}
}
 

兩種方法useFuture和useCompletableFuture相比：

首先，方法2 比 方法1 的程式碼簡單。在方法1裡，既要自己照顧執行緒池的建立和銷燬，還要負責對任務A和任務B的監控。而方法2，只需要用CompletableFuture的runAfterEither就完成了任務A、任務B和任務C之間的依賴關係的定義。

在方法2，甚至用一行程式碼就能完成：

CompletableFuture.runAsync(() -> work("A2")).runAfterEither(CompletableFuture.runAsync(() -> work("B2")), () -> work("C2")).get();
 

其次，方法2 比 方法1 高效。

方法1的主執行緒，要通過while(true)的方式不斷地輪詢任務A和任務B的執行狀況，浪費CPU資源，而方法2的主執行緒只需要在最後的get()上靜靜地等待任務C的完成。

下面是程式執行的輸出：

從方法1的輸出可以看出，任務C1的開始並不是緊隨著任務A1的完成，差了0.971秒，原因是在方法1裡，是對任務A1和任務B1都用get(1)來詢問他們的狀態，當其中一個任務先完成時，主執行緒可能正阻塞在另一個未完成任務的get上

而方法2完全不存在這樣的問題，任務C2的開始於任務A1的結束之間沒有任何的時間差。

有關CompletableFuture和CompletionStage，同學們應該去翻翻他們的javadoc，他們是jdk8對Fork/Join框架非常重要的貢獻，充分利用能幫助你用簡潔的程式碼就能寫出高效靈活的併發演算法。

留下一個作業題，用CompletableFuture來模擬專案管理裡的甘特圖。