用个小例子来介绍一下JDK8的CompletableFuture

代码要解决的问题是：在两个线程里并行执行任务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来模拟项目管理里的甘特图。