一 点睛

Future 接口可以创建出新的线程，并在新线程中执行异步操作。但是， 如果使用 Future 接口创建了多个线程，那么这些线程各自独立执行，不存在任务依赖关系，并且无法控制各个线程的执行步骤。

为了解决这种线程间的依赖关系，从 JDK 1.8 开始，Future 接口提供了一个新的实现类 CompletableFuture。CompletableFuture 不但可以创建出异步执行的线程，还可以控制线程的执行步骤，并且可以监控所有线程的结束时刻。例如，可以使用 CompletableFuture 创建 A 和 B 两个线程，然后规定 A 和 B 线程各需要执行 3个 不同的阶段，并且当 A和 B 全部执行完毕后，再触发某个方法。

public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {
    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
        return asyncSupplyStage(asyncPool, supplier);
    }

    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,
                                                   Executor executor) {
        return asyncSupplyStage(screenExecutor(executor), supplier);
    }

    public static CompletableFuture<Void> runAsync(Runnable runnable) {
        return asyncRunStage(asyncPool, runnable);
    }

    public static CompletableFuture<Void> runAsync(Runnable runnable,
                                               Executor executor) {
        return asyncRunStage(screenExecutor(executor), runnable);
    }
}

其中，supplyAsync() 用于有返回值的任务，runAsync() 用于没有返回值的任务，

除了这些用于执行线程任务的方法外，CompletableFuture 还提供了多线程执行时的两种结束逻辑：allOf() 和 anyOf()，如下所述。
1 allOf() 方法会一直阻塞，直到线程池 Executor 中所有线程全部执行完毕。

2 anyOf() 方法会一直阻塞，直到线程池 Executor 中任何一个线程执行完毕。

二 实战

1 需求

有1、2、3、4 四个数字，现要求创建4个线程对这些数字进行处理，并要求每个线程必须按照以下步骤执行。

a 对4个数字的值各加上64，使之转为 A、B、C、D 对应的 ASCII（A：65、B：66、C：67、D：68）。

b 将 ASCII 值转为对应的 A、B、C、D 字符。

c 将转后的 A、B、C、D 加入一个集合中。

最后，还要求当 A、B、C、D 4个线程全部执行完毕后，打印出转换后的结果集。

2 代码

package concurrent;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureDemo {
    public static void main(String[] args) {
        // 原始数据集
        CopyOnWriteArrayList<Integer> taskList = new CopyOnWriteArrayList();
        taskList.add(1);
        taskList.add(2);
        taskList.add(3);
        taskList.add(4);

        // 结果集
        List<Character> resultList = new ArrayList<>();
        //线程池，可容纳四个线程
        ExecutorService executorService = Executors.newFixedThreadPool(4);

        CompletableFuture[] cfs = taskList.stream()
                // 第一阶段
                .map(integer -> CompletableFuture.supplyAsync(
                        () -> calcASCII(integer), executorService)
                        // 第二阶段
                        .thenApply(i -> {
                            char c = (char) (i.intValue());
                            System.out.println("【阶段2】线程"
                                    + Thread.currentThread().getName() + "执行完毕，"
                                    + "已将int"
                                    + i + "转为了字符" + c);
                            return c;
                        })
                        // 第三阶段
                        .whenComplete((ch, e) -> {
                            resultList.add(ch);
                            System.out.println("【阶段3】线程" +
                                    Thread.currentThread().getName() + "执行完毕，" + "已将"
                                    + ch + "增加到了结果集" + resultList + "中");
                            executorService.shutdown();
                        })
                ).toArray(CompletableFuture[]::new);
        // 封装后无返回值，必须自己whenComplete()获取
        CompletableFuture.allOf(cfs).join();//future.get()

        System.out.println("完成！result=" + resultList);
    }

    // 计算i的ASCII值
    public static Integer calcASCII(Integer i) {
        try {
            if (i == 1) {
                Thread.sleep(5000);
            } else {
                Thread.sleep(1000);
            }
            //数字 -> A-D对应的ascii
            i = i + 64;
            System.out.println("【阶段1】线程" + Thread.currentThread().getName()
                    + "执行完毕，" + "已将" + i
                    + "转为了A(或B或C或D)对应的ASCII" + i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return i;
    }
}

3 测试结果

【阶段1】线程pool-1-thread-3执行完毕，已将67转为了A(或B或C或D)对应的ASCII67

【阶段1】线程pool-1-thread-4执行完毕，已将68转为了A(或B或C或D)对应的ASCII68

【阶段1】线程pool-1-thread-2执行完毕，已将66转为了A(或B或C或D)对应的ASCII66

【阶段2】线程pool-1-thread-3执行完毕，已将int67转为了字符C

【阶段2】线程pool-1-thread-4执行完毕，已将int68转为了字符D

【阶段2】线程pool-1-thread-2执行完毕，已将int66转为了字符B

【阶段3】线程pool-1-thread-3执行完毕，已将C增加到了结果集[C, D]中

【阶段3】线程pool-1-thread-4执行完毕，已将D增加到了结果集[C, D]中

【阶段3】线程pool-1-thread-2执行完毕，已将B增加到了结果集[C, D, B]中

【阶段1】线程pool-1-thread-1执行完毕，已将65转为了A(或B或C或D)对应的ASCII65

【阶段2】线程pool-1-thread-1执行完毕，已将int65转为了字符A

【阶段3】线程pool-1-thread-1执行完毕，已将A增加到了结果集[C, D, B, A]中

完成！result=[C, D, B, A]