CompletableFuture 使用示例

背景

Java异步编程离不开Future接口，但是Future接口提供的方法使用起来不够灵活。为了判断一个Future是否已经完成，我们可以：

• 通过调用get方法，以阻塞的形式获取执行结果。
• 调用有最大等待时间的get方法，以阻塞的形式获取执行结果。
• 反复轮询isDone方法，直到任务完成，获取结果。

以上3种方法都不够灵活，会造成线程阻塞或耗费CPU资源。需要用户过多的参与异步编程逻辑，对业务代码的侵入性较强。

另外用户如果需要异步执行多个任务，并且这些任务具有先后依赖关系。基于传统的方式我们需要大量使用锁，CountDownLatch和CyclicBarrier和阻塞队列等，编程十分复杂。

CompletableFuture是Future的增强版，提供了一系列的同步或异步任务执行操作。除此之外还能够对异步任务多个阶段的前后依赖关系进行控制。使用起来十分方便。

注意事项

所有的以async结尾的方法都为异步执行。它们都可以传入一个Executor线程池，用于异步执行。如果不指定线程池，默认使用ForkJoinPool.commonPool()

下面以所有的async异步方法为例，说明下CompletableFuture的使用方法。

静态方法

supplyAsync

提供初始数据。接收一个Supplier类型参数。

CompletableFuture completableFuture = CompletableFuture.supplyAsync(() -> 1);
completableFuture.thenApplyAsync((i) -> {
    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return i + 1;
    // 这里打印出2
}).thenAcceptAsync((i) -> System.out.println(i));

runAsync

异步执行任务，接收Runnable类型参数。

CompletableFuture.runAsync(() -> {
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("runAsync");
});

completedFuture

直接返回一个已经完成的CompletableFuture。接收一个任意类型数据为参数。

CompletableFuture completableFuture = CompletableFuture.completedFuture(500);
// 此处可以立刻返回500
System.out.println(completableFuture.get());

allOf

参数接收任意多个CompletableFuture。该方法返回一个新的CompletableFuture，只有在参数所有的CompletableFuture完成的时候它才会完成。

long start = System.currentTimeMillis();

CompletableFuture completableFuture1 = CompletableFuture.runAsync(() -> {
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("runAsync1");
});

CompletableFuture completableFuture2 = CompletableFuture.runAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("runAsync2");
});

// 等待两个CompletableFuture都完成的时候，future才会完成
CompletableFuture future = CompletableFuture.allOf(completableFuture1, completableFuture2);

// 阻塞到CompletableFuture1完成
future.get();
// 耗时大于3000毫秒
System.out.println(System.currentTimeMillis() - start);

anyOf

和allOf一样，返回一个新的CompletableFuture，参数中任意一个CompletableFuture完成时它就能完成。

long start = System.currentTimeMillis();

CompletableFuture completableFuture1 = CompletableFuture.runAsync(() -> {
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("runAsync1");
});

CompletableFuture completableFuture2 = CompletableFuture.runAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("runAsync2");
});

// 两个CompletableFuture有任何一个完成，future就可以完成
CompletableFuture