JUC下的异步编程工具使用详情以及源码分析（FutureTask、CompletableFuture）

2.2.1 supplyAsync

CompletableFuture如果不提供线程池的话，默认使用的ForkJoinPool，而ForkJoinPool内部是守护线程，如果main线程结束了，守护线程会跟着一起结束

public static void main(String[] args)  {
    // 生产者，可以指定返回结果
    CompletableFuture<String> firstTask = CompletableFuture.supplyAsync(() -> {
        System.out.println("异步任务开始执行");
        System.out.println("异步任务执行结束");
        return "返回结果";
    });

    String result1 = firstTask.join();
    String result2 = null;
    try {
        result2 = firstTask.get();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }

    System.out.println(result1 + "," + result2);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

console

异步任务开始执行
异步任务执行结束
返回结果,返回结果

Process finished with exit code 0
1
2
3
4
5

调用completeFuture.get()方法会导致阻塞，直到任务执行结束

也可以使用非阻塞的方法，比如while循环调用isDone()方法为判断任务是否执行完毕，如果没有执行完毕可以去做别的事情

2.2.2 runAsync

当前方式既不会接收参数，也不会返回任何结果，非常基础的任务编排方式

public static void main(String[] args) throws IOException {
    CompletableFuture.runAsync(() -> {
        System.out.println("任务go");
        System.out.println("任务done");
    });

    System.in.read();
}
1
2
3
4
5
6
7
8

console

任务go
任务done
1
2

2.2.3 thenApply，thenApplyAsync

有任务A，还有任务B

任务B需要在任务A执行完毕后再执行

而且任务B需要任务A的返回结果

任务B自身也有返回结果

thenApply可以拼接异步任务，前置任务处理完之后，将返回结果交给后置任务，然后后置任务再执行（使用的同一个线程执行）

thenApply提供了带有Async的方法，可以指定每个任务使用的具体线程池

public static void main(String[] args) throws IOException {
    ExecutorService executor = Executors.newFixedThreadPool(10);

    /*CompletableFuture taskA = CompletableFuture.supplyAsync(() -> {
        String id = UUID.randomUUID().toString();
        System.out.println("执行任务A：" + id);
        return id;
    });
    CompletableFuture taskB = taskA.thenApply(result -> {
        System.out.println("任务B获取到任务A结果：" + result);
        result = result.replace("-", "");
        return result;
    });

    System.out.println("main线程拿到结果：" + taskB.join());*/

    CompletableFuture<String> taskB = CompletableFuture.supplyAsync(() -> {
        String id = UUID.randomUUID().toString();
        System.out.println("执行任务A：" + id + "," + Thread.currentThread().getName());
        return id;
    }).thenApplyAsync(result -> {
        System.out.println("任务B获取到任务A结果：" + result + "," + Thread.currentThread().getName());
        result = result.replace("-", "");
        return result;
    },executor);

    System.out.println("main线程拿到结果：" + taskB.join());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2.2.4 thenAccept，thenAcceptAsync

套路和thenApply一样，都是任务A和任务B的拼接

前置任务需要有返回结果，后置任务会接收前置任务的结果，返回后置任务没有返回值

public static void main(String[] args) throws IOException {
    CompletableFuture.supplyAsync(() -> {
        System.out.println("任务A");
        return "abcdefg";
    }).thenAccept(result -> {
        System.out.println("任务b，拿到结果处理：" + result);
    });

    System.in.read();
}
1
2
3
4
5
6
7
8
9
10

2.2.5 thenRun，thenRunAsync

套路和thenApply，thenAccept一样，都是任务A和任务B的拼接

前置任务没有返回结果，后置任务不接收前置任务结果，后置任务也会有返回结果

public static void main(String[] args) throws IOException {
    CompletableFuture.runAsync(() -> {
        System.out.println("任务A！！");
    }).thenRun(() -> {
        System.out.println("任务B！！");
    });
  
    System.in.read();
}
1
2
3
4
5
6
7
8
9

thenRunAsync与thenAccept一致，只是说可以传线程池进行执行，如果不传则使用默认线程池

private static final Executor asyncPool = useCommonPool ?
     ForkJoinPool.commonPool() : new ThreadPerTaskExecutor();
1
2

2.2.6 thenCombine，thenAcceptBoth，runAfterBoth

比如有任务A，任务B，任务C。任务A和任务B并行执行，等到任务A和任务B全部执行完毕后，再执行任务C

A+B ------ C

基于前面thenApply，thenAccept，thenRun知道了一般情况三种任务的概念

thenCombine以及thenAcceptBoth还有runAfterBoth的区别是一样的

public static void main(String[] args) throws IOException {
	long start = System.currentTimeMillis();
    CompletableFuture<Integer> taskC = CompletableFuture.supplyAsync(() -> {
        System.out.println("线程A：" + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 50;
    }).thenCombine(CompletableFuture.supplyAsync(() -> {
        System.out.println("线程B:" + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 49;
    }), (resA, resB) -> {
        System.out.println("线程C:" + Thread.currentThread().getName());
        return resA + resB;
    });
    System.out.println(taskC.join());
    System.out.println("执行时间：" + (System.currentTimeMillis() - start) + "ms");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

console

线程A：ForkJoinPool.commonPool-worker-9
线程B:ForkJoinPool.commonPool-worker-2
线程C:ForkJoinPool.commonPool-worker-9
99
执行时间：2039ms

Process finished with exit code 0
1
2
3
4
5
6
7

2.2.7 applyToEither，acceptEither，runAfterEither

比如有任务A，任务B，任务C。任务A和任务B并行执行，只要任务A或者任务B执行任一任务执行完毕，就会开始执行任务C

A or B ----- C

applyToEither，acceptEither，runAfterEither三个方法拼接任务的方式都是一样的

区别

• applyToEither：可以接收结果并且返回结果
• acceptEither：可以接收结果没有返回结果
• runAfterEither：不接收结果也没返回结果

public static void main(String[] args) throws IOException {
    CompletableFuture<Integer> task = CompletableFuture.supplyAsync(() -> {
        System.out.println("任务A, " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 88;
    }).applyToEither(CompletableFuture.supplyAsync(() -> {
        System.out.println("任务B, " + Thread.currentThread().getName());
        return 77;
    }), resultFirst -> {
        System.out.println("任务C，获取到值：" + resultFirst + " " + Thread.currentThread().getName());
        return resultFirst;
    });
    System.out.println(task.join());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

console

任务A, ForkJoinPool.commonPool-worker-9
任务B, ForkJoinPool.commonPool-worker-2
任务C，获取到值：77 main
77

Process finished with exit code 0
1
2
3
4
5
6

2.2.8 exceptionally，thenCompose，handle

• exceptionally：这个也是拼接任务的方式，但是只有前面业务执行时出现异常了，才会执行当前方法来处理只有异常出现时，CompletableFuture的编排任务没有处理完时，才会触发

  public static void main(String[] args) throws IOException {
  	CompletableFuture<Integer> task = CompletableFuture.supplyAsync(() -> {
          System.out.println("任务A, " + Thread.currentThread().getName());
          int i = 1/0;
          return 88;
      }).applyToEither(CompletableFuture.supplyAsync(() -> {
          System.out.println("任务B, " + Thread.currentThread().getName());
          return 77;
      }), resultFirst -> {
          System.out.println("任务C，获取到值：" + resultFirst + " " + Thread.currentThread().getName());
          return resultFirst;
      }).exceptionally(e -> {
          // exception
          System.out.println("获取到异常, " + e.getMessage());
          return -1;
      });
      System.out.println("执行结果, " + task.join());
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18

  console

  任务A, ForkJoinPool.commonPool-worker-9
  任务B, ForkJoinPool.commonPool-worker-2
  获取到异常, java.lang.ArithmeticException: / by zero
  执行结果, -1
  
  Process finished with exit code 0
  1
  2
  3
  4
  5
  6

• whenComplete：可以拿到返回结果同时也可以拿到出现的异常信息，但是whenComplete本身是Consumer不能返回结果。无法帮你捕获异常（程序执行的最后异常会抛出），但是可以拿到异常返回的结果

  public static void main(String[] args) throws IOException {
  	CompletableFuture<Integer> task = CompletableFuture.supplyAsync(() -> {
          System.out.println("任务A, " + Thread.currentThread().getName());
          int i = 1/0;
          return 88;
      }).applyToEither(CompletableFuture.supplyAsync(() -> {
          System.out.println("任务B, " + Thread.currentThread().getName());
          return 77;
      }), resultFirst -> {
          System.out.println("任务C，获取到值：" + resultFirst + " " + Thread.currentThread().getName());
          return resultFirst;
      }).whenComplete((r, e) -> {
          System.out.println("获取到结果：" + r);
          System.out.println("获取到异常, " + e);
          System.out.println("这里会被执行");
      });
      System.out.println("执行结果, " + task.join()); // 此处会被whenComplete抛出的异常打断
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18

  console

  任务A, ForkJoinPool.commonPool-worker-9
  任务B, ForkJoinPool.commonPool-worker-2
  获取到结果：null
  获取到异常, java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
  这里会被执行
  Exception in thread "main" java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
  	at java.util.concurrent.CompletableFuture.encodeThrowable(CompletableFuture.java:273)
  	at java.util.concurrent.CompletableFuture.completeThrowable(CompletableFuture.java:280)
  	at java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1606)
  	at java.util.concurrent.CompletableFuture$AsyncSupply.exec(CompletableFuture.java:1596)
  	at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289)
  	at java.util.concurrent.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:1067)
  	at java.util.concurrent.ForkJoinPool.runWorker(ForkJoinPool.java:1703)
  	at java.util.concurrent.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:172)
  Caused by: java.lang.ArithmeticException: / by zero
  	at com.armin.thread.tool.CompletableFutureTest.lambda$testWhenComplete$0(CompletableFutureTest.java:28)
  	at java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1604)
  	... 5 more
  
  Process finished with exit code 1
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21

• handle：可以拿到返回结果同时也可以拿到出现的异常信息，并且也可以指定返回托底数据。可以捕获异常的，异常不会抛出去

whenComplete，handle这两个也是异常处理的套路，可以根据方法描述发现，他的功能方向比exceptionally要更加丰富

public static void main(String[] args) throws IOException {
    CompletableFuture<Integer> task = CompletableFuture.supplyAsync(() -> {
        System.out.println("任务A, " + Thread.currentThread().getName());
        int i = 1/0;
        return 88;
    }).applyToEither(CompletableFuture.supplyAsync(() -> {
        System.out.println("任务B, " + Thread.currentThread().getName());
        try {
            Thread.sleep(10); // 保证任务A先执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 77;
    }), resultFirst -> {
        System.out.println("任务C，获取到值：" + resultFirst + " " + Thread.currentThread().getName());
        return resultFirst;
    }).handle((r, e) -> {
        System.out.println("获取到结果：" + r);
        System.out.println("获取到异常, " + e);
        System.out.println("这里会被执行");
        return -1;
    });
    System.out.println("执行结果, " + task.join());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

console

任务A, ForkJoinPool.commonPool-worker-9
任务B, ForkJoinPool.commonPool-worker-9
获取到结果：null
获取到异常, java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
这里会被执行
执行结果, -1

Process finished with exit code 0
1
2
3
4
5
6
7
8

2.2.9 allOf，anyOf

allOf的方式是让内部编写多个CompletableFuture的任务，多个任务都执行完后，才会继续执行你后续拼接的任务

allOf返回的CompletableFuture是Void，没有返回结果

public static void main(String[] args) throws IOException {
    long start = System.currentTimeMillis();
    CompletableFuture<Void> task = CompletableFuture.allOf(
            CompletableFuture.runAsync(() -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务A");
            }),
            CompletableFuture.runAsync(() -> {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务B");
            }),
            CompletableFuture.runAsync(() -> {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务C");
            })
    ).thenRun(() -> {
        System.out.println("任务D");
    });
    System.out.println(task.join()); //阻塞主线程等待task任务执行完毕，便于查看执行过程
    System.out.println("执行时长:" + (System.currentTimeMillis() - start) + "ms");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

console

任务A
任务B
任务C
任务D
null
执行时长:3037ms

Process finished with exit code 0
1
2
3
4
5
6
7
8

anyOf是基于多个CompletableFuture的任务，只要有一个任务执行完毕就继续执行后续，最先执行完的任务做作为返回结果的入参

public static void main(String[] args) throws IOException {
	long start = System.currentTimeMillis();
    CompletableFuture<Void> task = CompletableFuture.anyOf(
            CompletableFuture.supplyAsync(() -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务A");
                return "A";
            }),
            CompletableFuture.supplyAsync(() -> {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务B");
                return "B";
            }),
            CompletableFuture.supplyAsync(() -> {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务C");
                return "C";
            })
    ).thenAccept(r -> {
        System.out.println("任务D执行，" + r + "先执行完毕的");
    });
    System.out.println(task.join()); //阻塞主线程等待task任务执行完毕，便于查看执行过程
    System.out.println("执行时长:" + (System.currentTimeMillis() - start) + "ms");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

console

任务A
任务D执行，A先执行完毕的
null
执行时长:1050ms

Process finished with exit code 0
1
2
3
4
5
6

2.3 CompletableFuture源码分析

CompletableFuture的源码内容特别多。不需要把所有源码都看了，更多的是要掌握整个CompletableFuture的源码执行流程，以及任务的执行时机。

从CompletableFuture中比较简单的方法作为分析的入口，从而掌握整体执行的流程

2.3.1 当前任务执行方式

将任务和CompletableFuture封装到一起，再执行封装好的具体对象的run方法即可

// 提交任务到CompletableFuture
public static CompletableFuture<Void> runAsync(Runnable runnable) {
    // asyncPool：执行任务的线程池
    // runnable：具体任务。
    return asyncRunStage(asyncPool, runnable);
}

// 内部执行的方法
static CompletableFuture<Void> asyncRunStage(Executor e, Runnable f) {
    // 对任务做非空校验
    if (f == null) throw new NullPointerException();
    // 直接构建了CompletableFuture的对象，作为最后的返回结果
    CompletableFuture<Void> d = new CompletableFuture<Void>();
    // 将任务和CompletableFuture对象封装为了AsyncRun的对象
    // 将封装好的任务交给了线程池去执行
    e.execute(new AsyncRun(d, f));
    // 返回构建好的CompletableFuture
    return d;
}

// 封装任务的AsyncRun类信息
static final class AsyncRun extends ForkJoinTask<Void> implements Runnable, AsynchronousCompletionTask {
    // 声明存储CompletableFuture对象以及任务的成员变量
    CompletableFuture<Void> dep; 
    Runnable fn;

    // 将传入的属性赋值给成员变量
    AsyncRun(CompletableFuture<Void> dep, Runnable fn) {
        this.dep = dep; 
        this.fn = fn;
    }
    // 当前对象作为任务提交给线程池之后，必然会执行当前方法
    public void run() {
        // 声明局部变量
        CompletableFuture<Void> d; Runnable f;
        // 将成员变量赋值给局部变量，并且做非空判断
        if ((d = dep) != null && (f = fn) != null) {
            // help GC，将成员变量置位null，只要当前任务结束后，成员变量也拿不到引用。
            dep = null; fn = null;
            // 先确认任务没有执行。
            if (d.result == null) {
                try {
                    // 直接执行任务
                    f.run();
                    // 当前方法是针对Runnable任务的，不能将结果置位null
                    // 要给没有返回结果的Runnable做一个返回结果
                    d.completeNull();
                } catch (Throwable ex) {
                    // 异常结束！
                    d.completeThrowable(ex);
                }
            }
            d.postComplete();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

2.3.2 任务编排的存储&执行方式

首先如果要在前继任务处理后，执行后置任务的话

有两种情况：

• 前继任务如果没有执行完毕，后置任务需要先放在stack栈结构中存储
• 前继任务已经执行完毕了，后置任务就应该直接执行，不需要在往stack中存储了

如果单独采用thenRun在一个任务后面指定多个后继任务，CompletableFuture无法保证具体的执行顺序，而影响执行顺序的是前继任务的执行时间，以及后置任务编排的时机

2.3.3 任务编排流程

// 编排任务，前继任务搞定，后继任务再执行
public CompletableFuture<Void> thenRun(Runnable action) {
    // 执行了内部的uniRunStage方法，
    // null：线程池，现在没给。
    // action：具体要执行的任务
    return uniRunStage(null, action);
}

// 内部编排任务方法
private CompletableFuture<Void> uniRunStage(Executor e, Runnable f) {
    // 后继任务不能为null，健壮性判断
    if (f == null) throw new NullPointerException();
    // 创建CompletableFuture对象d，与后继任务f绑定
    CompletableFuture<Void> d = new CompletableFuture<Void>();
    // 如果线程池不为null，代表异步执行，将任务压栈
    // 如果线程池是null，先基于uniRun尝试下，看任务能否执行
    if (e != null || !d.uniRun(this, f, null)) {
        // 如果传了线程池，这边需要走一下具体逻辑
        // e：线程池
        // d：后继任务的CompletableFuture
        // this：前继任务的CompletableFuture
        // f：后继任务
        UniRun<T> c = new UniRun<T>(e, d, this, f);
        // 将封装好的任务，push到stack栈结构
        // 只要前继任务没结束，这边就可以正常的将任务推到栈结构中
        // 放入栈中可能会失败
        push(c);
        // 无论压栈成功与否，都要尝试执行以下。
        c.tryFire(SYNC);
    }
    // 无论任务执行完毕与否，都要返回后继任务的CompletableFuture
    return d;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

2.3.4 查看后置任务执行时机

任务在编排到前继任务时，因为前继任务已经结束了，这边后置任务会主动的执行

// 后置任务无论压栈成功与否，都需要执行tryFire方法
static final class UniRun<T> extends UniCompletion<T,Void> {

    Runnable fn;
    // executor：线程池
    // dep：后置任务的CompletableFuture
    // src：前继任务的CompletableFuture
    // fn：具体的任务
    UniRun(Executor executor, CompletableFuture<Void> dep,CompletableFuture<T> src, Runnable fn) {
        super(executor, dep, src); this.fn = fn;
    }

    final CompletableFuture<Void> tryFire(int mode) {
        // 声明局部变量
        CompletableFuture<Void> d; CompletableFuture<T> a;
        // 赋值局部变量
        // (d = dep) == null：赋值加健壮性校验
        if ((d = dep) == null ||
            // 调用uniRun。
            // a：前继任务的CompletableFuture
            // fn：后置任务
            // 第三个参数：传入的是this，是UniRun对象
            !d.uniRun(a = src, fn, mode > 0 ? null : this))
            // 进到这，说明前继任务没结束，等！
            return null;
        dep = null; src = null; fn = null;
        return d.postFire(a, mode);
    }
}

// 是否要主动执行任务
final boolean uniRun(CompletableFuture<?> a, Runnable f, UniRun<?> c) {
    // 方法要么正常结束，要么异常结束
    Object r; Throwable x;
    // a == null：健壮性校验
    // (r = a.result) == null：判断前继任务结束了么？
    // f == null：健壮性校验
    if (a == null || (r = a.result) == null || f == null)
        // 到这代表任务没结束。
        return false;
    // 后置任务执行了没？ == null，代表没执行
    if (result == null) {
        // 如果前继任务的结果是异常结束。如果前继异常结束，直接告辞，封装异常结果
        if (r instanceof AltResult && (x = ((AltResult)r).ex) != null)
            completeThrowable(x, r);
        else
            // 到这，前继任务正常结束，后置任务正常执行
            try {
                // 如果基于tryFire(SYNC)进来，这里的C不为null，执行c.claim
                // 如果是因为没有传递executor，c就是null，不会执行c.claim
                if (c != null && !c.claim())
                    // 如果返回false，任务异步执行了，直接return false
                    return false;
                // 如果claim没有基于线程池运行任务，那这里就是同步执行
                // 直接f.run了。
                f.run();
                // 封装Null结果
                completeNull();
            } catch (Throwable ex) {
                // 封装异常结果
                completeThrowable(ex);
            }
    }
    return true;
}

// 异步的线程池处理任务
final boolean claim() {
    Executor e = executor;
    if (compareAndSetForkJoinTaskTag((short)0, (short)1)) {
        // 只要有线程池对象，不为null
        if (e == null)
            return true;
        executor = null; // disable
        // 基于线程池的execute去执行任务
        e.execute(this);
    }
    return false;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

前继任务执行完毕后，基于嵌套的方式执行后置

// A：嵌套了B+C，  B：嵌套了D+E
// 前继任务搞定，遍历stack执行后置任务
// A任务处理完，解决嵌套的B和C
final void postComplete() {
    // f：前继任务的CompletableFuture
    // h：存储后置任务的栈结构
    CompletableFuture<?> f = this; Completion h;
    // (h = f.stack) != null：赋值加健壮性判断，要确保栈中有数据
    while ((h = f.stack) != null ||
            // 循环一次后，对后续节点的赋值以及健壮性判断，要确保栈中有数据
           (f != this && (h = (f = this).stack) != null)) {
        // t：当前栈中任务的后续任务
        CompletableFuture<?> d; Completion t;
        // 拿到之前的栈顶h后，将栈顶换数据
        if (f.casStack(h, t = h.next)) {
            if (t != null) {
                if (f != this) {
                    pushStack(h);
                    continue;
                }
                h.next = null;    // detach
            }
            // 执行tryFire方法，
            f = (d = h.tryFire(NESTED)) == null ? this : d;
        }
    }
}

// 回来了  NESTED == -1
final CompletableFuture<Void> tryFire(int mode) {
    CompletableFuture<Void> d; CompletableFuture<T> a;
    if ((d = dep) == null ||
        !d.uniRun(a = src, fn, mode > 0 ? null : this))
        return null;
    dep = null; src = null; fn = null;
    // 内部会执行postComplete，运行B内部嵌套的D和E
    return d.postFire(a, mode);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

2.4 CompletableFuture执行流程图

补充

此图claim还有一种情况是线程池为null会让当前线程去同步调用（直接调用run）