简介

先说Future, 它用来描述一个异步计算的结果。isDone方法可以用来检查计算是否完成，get方法可以用来获取结果，直到完成前一直阻塞当前线程，cancel方法可以取消任务。而对于结果的获取，只能通过阻塞(get())或者轮询的方式[while(!isDone)]. 阻塞的方式违背了异步编程的理念，轮询的方式耗费无谓的CPU资源（CPU空转）。于是，CompletableFuture应运而生。

样例

后面介绍的源码都会以下面的用例为切入点，循着调用轨迹理解源码。如果任务很耗时，记得传Executor, 或者方法末尾加上future.get(); 因为CompletableFuture默认使用ForkJoinPool, 而ForkJoinPool里面的线程都是daemon线程，主线程跑完了，虚拟机也就over了。

  1.      public void whenComplete() {
  2.          CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 100);
  3.          future.whenComplete((l, r) -> System.out.println(l));
  4.      }
  5.  
  6.      public void thenApply() {
  7.          CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 100);
  8.          future.thenApply(i -> -i);
  9.      }
  10.  
  11.      public void thenAccept() {
  12.          CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 100);
  13.          future.thenAccept(System.out::println);
  14.      }
  15.  
  16.      public void thenRun() {
  17.          CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 100);
  18.          future.thenRun(() -> System.out.println("Done"));
  19.      }
  20.  
  21.      public void thenAcceptBoth() {
  22.          CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 100);
  23.          CompletableFuture<Integer> other = CompletableFuture.supplyAsync(() -> 200);
  24.          future.thenAcceptBoth(other, (x, y) -> System.out.println(x + y));
  25.      }
  26.  
  27.      public void acceptEither() {
  28.          CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 100);
  29.          CompletableFuture<Integer> other = CompletableFuture.supplyAsync(() -> 200);
  30.          future.acceptEither(other, System.out::println);
  31.  
  32.      }
  33.  
  34.      public void allOf() {
  35.          CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 100);
  36.          CompletableFuture<Integer> second = CompletableFuture.supplyAsync(() -> 200);
  37.          CompletableFuture<Integer> third = CompletableFuture.supplyAsync(() -> 300);
  38.          CompletableFuture.allOf(future, second, third);
  39.  
  40.      }
  41.  
  42.      public void anyOf() throws InterruptedException, ExecutionException {
  43.          CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 100);
  44.          CompletableFuture<Integer> second = CompletableFuture.supplyAsync(() -> 200);
  45.          CompletableFuture<Integer> third = CompletableFuture.supplyAsync(() -> 300);
  46.          CompletableFuture.anyOf(future, second, third);
  47.      }

源码分析

supplyAsync

supplyAsync(Supplier<U> supplier)

  1.      public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
  2.          return asyncSupplyStage(asyncPool, supplier); // asyncPool, ForkJoinPool.commonPool()或者ThreadPerTaskExecutor(实现了Executor接口，里面的内容是{new Thread(r).start();})
  3.      }

asyncSupplyStage(Executor e, Supplier<U> f)

  1.      static <U> CompletableFuture<U> asyncSupplyStage(Executor e, Supplier<U> f) {
  2.          if (f == null)
  3.              throw new NullPointerException();
  4.          CompletableFuture<U> d = new CompletableFuture<U>(); // 构建一个新的CompletableFuture, 以此构建AsyncSupply作为Executor的执行参数
  5.          e.execute(new AsyncSupply<U>(d, f)); // AsyncSupply继承了ForkJoinTask, 实现了Runnable, AsynchronousCompletionTask接口
  6.          return d; // 返回d，立返
  7.      }

AsyncSupply

  1.      // CompletableFuture的静态内部类，作为一个ForkJoinTask
  2.      static final class AsyncSupply<T> extends ForkJoinTask<Void> implements Runnable, AsynchronousCompletionTask {
  3.          CompletableFuture<T> dep; // AsyncSupply作为一个依赖Task，dep作为这个Task的Future
  4.          Supplier<T> fn; // fn作为这个Task的具体执行逻辑，函数式编程
  5.  
  6.          AsyncSupply(CompletableFuture<T> dep, Supplier<T> fn) {
  7.              this.dep = dep;
  8.              this.fn = fn;
  9.          }
  10.  
  11.          public final Void getRawResult() {
  12.              return null;
  13.          }
  14.  
  15.          public final void setRawResult(Void v) {
  16.          }
  17.  
  18.          public final boolean exec() {
  19.              run();
  20.              return true;
  21.          }
  22.  
  23.          public void run() {
  24.              CompletableFuture<T> d;
  25.              Supplier<T> f;
  26.              if ((d = dep) != null && (f = fn) != null) { // 非空判断
  27.                  dep = null;
  28.                  fn = null;
  29.                  if (d.result == null) { // 查看任务是否结束，如果已经结束(result != null)，直接调用postComplete()方法
  30.                      try {
  31.                          d.completeValue(f.get()); // 等待任务结束，并设置结果
  32.                      } catch (Throwable ex) {
  33.                          d.completeThrowable(ex); // 异常
  34.                      }
  35.                  }
  36.                  d.postComplete(); // 任务结束后，会执行所有依赖此任务的其他任务，这些任务以一个无锁并发栈的形式存在
  37.              }
  38.          }
  39.      }

postComplete()

  1.      final void postComplete() {
  2.          CompletableFuture<?> f = this; // 当前CompletableFuture
  3.          Completion h; // 无锁并发栈，(Completion next), 保存的是依靠当前的CompletableFuture一串任务，完成即触发（回调）
  4.          while ((h = f.stack) != null || (f != this && (h = (f = this).stack) != null)) { // 当f的stack为空时，使f重新指向当前的CompletableFuture，继续后面的结点
  5.              CompletableFuture<?> d;
  6.              Completion t;
  7.              if (f.casStack(h, t = h.next)) { // 从头遍历stack，并更新头元素
  8.                  if (t != null) {
  9.                      if (f != this) { // 如果f不是当前CompletableFuture，则将它的头结点压入到当前CompletableFuture的stack中，使树形结构变成链表结构，避免递归层次过深
  10.                          pushStack(h);
  11.                          continue; // 继续下一个结点，批量压入到当前栈中
  12.                      }
  13.                      h.next = null; // 如果是当前CompletableFuture, 解除头节点与栈的联系
  14.                  }
  15.                  f = (d = h.tryFire(NESTED)) == null ? this : d; // 调用头节点的tryFire()方法，该方法可看作Completion的钩子方法，执行完逻辑后，会向后传播的
  16.              }
  17.          }
  18.      }

示意图

每个CompletableFuture持有一个Completion栈stack, 每个Completion持有一个CompletableFuture -> dep, 如此递归循环下去，是层次很深的树形结构，所以想办法将其变成链表结构。

首先取出头结点，下图中灰色Completion结点，它会返回一个CompletableFuture, 同样也拥有一个stack，策略是遍历这个CompletableFuture的stack的每个结点，依次压入到当前CompletableFuture的stack中，关系如下箭头所示，灰色结点指的是处理过的结点。

第一个Completion结点返回的CompletableFuture, 将拥有的stack里面的所有结点都压入了当前CompletableFuture的stack里面

后续的Completion结点返回的CompletableFuture, 将拥有的stack里面的所有结点都压入了当前CompletableFuture的stack里面，重新构成了一个链表结构，后续也按照前面的逻辑操作，如此反复，便会遍历完所有的CompletableFuture, 这些CompletableFuture(叶子结点)的stack为空，也是结束条件。

postComplete()最后调用的是Completion#tryFire()方法，先看下Completion的数据结构

Completion

  1.      abstract static class Completion extends ForkJoinTask<Void> implements Runnable, AsynchronousCompletionTask {
  2.          volatile Completion next; // 无锁并发栈
  3.  
  4.          /**
  5.           * 钩子方法，有三种模式，postComplete()方法里面使用的是NESTED模式，避免过深的递归调用 SYNC, ASYNC, or NESTED
  6.           */
  7.          abstract CompletableFuture<?> tryFire(int mode); // run()和exec()都调用了这个钩子方法
  8.  
  9.          /** cleanStack()方法里有用到 */
  10.          abstract boolean isLive();
  11.  
  12.          public final void run() {
  13.              tryFire(ASYNC);
  14.          }
  15.  
  16.          public final boolean exec() {
  17.              tryFire(ASYNC);
  18.              return true;
  19.          }
  20.  
  21.          public final Void getRawResult() {
  22.              return null;
  23.          }
  24.  
  25.          public final void setRawResult(Void v) {
  26.          }
  27.      }

static final int SYNC = 0;       同步
static final int ASYNC = 1;    异步
static final int NESTED = -1; 嵌套

继承了ForkJoinTask, 实现了Runnable, AsynchronousCompletionTask接口，它有诸多子类，如下图

后面的方法都对应着不同的子类。

先看一个子类UniCompletion

  1.      abstract static class UniCompletion<T,V> extends Completion {
  2.          Executor executor;                 // 执行器
  3.          CompletableFuture<V> dep;          // 依赖的任务
  4.          CompletableFuture<T> src;          // 被依赖的任务
  5.  
  6.          UniCompletion(Executor executor, CompletableFuture<V> dep,
  7.                        CompletableFuture<T> src) {
  8.              this.executor = executor; this.dep = dep; this.src = src;
  9.          }
  10.  
  11.          final boolean claim() { // 如果当前任务可以被执行，返回true，否则，返回false; 保证任务只被执行一次
  12.              Executor e = executor;
  13.              if (compareAndSetForkJoinTaskTag((short)0, (short)1)) {
  14.                  if (e == null)
  15.                      return true;
  16.                  executor = null; // 设置为不可用
  17.                  e.execute(this);
  18.              }
  19.              return false;
  20.          }
  21.  
  22.          final boolean isLive() { return dep != null; }
  23.      }

claim()方法保证任务只被执行一次。

whenComplete

whenComplete()/whenCompleteAsync()

  1.      public CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action) {
  2.          return uniWhenCompleteStage(null, action);
  3.      }
  4.  
  5.      public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action) {
  6.          return uniWhenCompleteStage(asyncPool, action);
  7.      }

xxx和xxxAsync方法的区别是，有没有asyncPool作为入参，有的话，任务直接入参，不检查任务是否完成。uniWhenCompleteStage方法有说明。

uniWhenCompleteStage(Executor e, BiConsumer<? super T, ? super Throwable> f)

  1.      private CompletableFuture<T> uniWhenCompleteStage(Executor e, BiConsumer<? super T, ? super Throwable> f) {
  2.          if (f == null)
  3.              throw new NullPointerException();
  4.          CompletableFuture<T> d = new CompletableFuture<T>(); // 构建future
  5.          if (e != null || !d.uniWhenComplete(this, f, null)) { // 如果线程池不为空，直接构建任务入栈，并调用tryFire()方法；否则，调用uniWhenComplete()方法，检查依赖的那个任务是否完成，没有完成返回false,
  6.                                                                  // 完成了返回true, 以及后续一些操作。
  7.              UniWhenComplete<T> c = new UniWhenComplete<T>(e, d, this, f); // UniWhenComplete继承了UniCompletion
  8.              push(c);
  9.              c.tryFire(SYNC); // 先调一下钩子方法，检查一下任务是否结束
  10.          }
  11.          return d;
  12.      }

uniWhenComplete(CompletableFuture<T> a, BiConsumer<? super T, ? super Throwable> f, UniWhenComplete<T> c)

  1.      final boolean uniWhenComplete(CompletableFuture<T> a, BiConsumer<? super T, ? super Throwable> f, UniWhenComplete<T> c) {
  2.          Object r;
  3.          T t;
  4.          Throwable x = null;
  5.          if (a == null || (r = a.result) == null || f == null) // 被依赖的任务还未完成
  6.              return false;
  7.          if (result == null) { // 被依赖的任务完成了
  8.              try {
  9.                  if (c != null && !c.claim()) // 判断任务是否能被执行
  10.                      return false;
  11.                  if (r instanceof AltResult) { // 判断异常，AltResult类型很简单，里面只有一个属性Throwable ex;
  12.                      x = ((AltResult) r).ex;
  13.                      t = null;
  14.                  } else {
  15.                      @SuppressWarnings("unchecked")
  16.                      T tr = (T) r; // 正常的结果
  17.                      t = tr;
  18.                  }
  19.                  f.accept(t, x); // 执行任务
  20.                  if (x == null) {
  21.                      internalComplete(r); // 任务的结果设置为被依赖任务的结果
  22.                      return true;
  23.                  }
  24.              } catch (Throwable ex) {
  25.                  if (x == null)
  26.                      x = ex; // 记录异常
  27.              }
  28.              completeThrowable(x, r); // 设置异常和结果
  29.          }
  30.          return true;
  31.      }

push()

  1.      final void push(UniCompletion<?, ?> c) {
  2.          if (c != null) {
  3.              while (result == null && !tryPushStack(c))
  4.                  lazySetNext(c, null); // 失败重置c的next域
  5.          }
  6.      }
  7.  
  8.      final boolean tryPushStack(Completion c) {
  9.          Completion h = stack;
  10.          lazySetNext(c, h);
  11.          return UNSAFE.compareAndSwapObject(this, STACK, h, c);
  12.      }
  13.  
  14.      static void lazySetNext(Completion c, Completion next) {
  15.          UNSAFE.putOrderedObject(c, NEXT, next);
  16.      }

UniWhenComplete

  1.      static final class UniWhenComplete<T> extends UniCompletion<T, T> {
  2.          BiConsumer<? super T, ? super Throwable> fn;
  3.  
  4.          UniWhenComplete(Executor executor, CompletableFuture<T> dep, CompletableFuture<T> src,
  5.                  BiConsumer<? super T, ? super Throwable> fn) {
  6.              super(executor, dep, src);
  7.              this.fn = fn;
  8.          }
  9.  
  10.          final CompletableFuture<T> tryFire(int mode) { // 钩子方法
  11.              CompletableFuture<T> d; // 依赖的任务
  12.              CompletableFuture<T> a; // 被依赖的任务
  13.              if ((d = dep) == null || !d.uniWhenComplete(a = src, fn, mode > 0 ? null : this)) // 如果是异步模式(mode = 1),就不判断任务是否结束
  14.                  return null; // dep为空，说明已经调用过了
  15.              dep = null;
  16.              src = null;
  17.              fn = null;
  18.              return d.postFire(a, mode); // 钩子方法之后的处理
  19.          }
  20.      }

postFire(CompletableFuture<?> a, int mode)

  1.      final CompletableFuture<T> postFire(CompletableFuture<?> a, int mode) {
  2.          if (a != null && a.stack != null) { // 被依赖的任务存在，且stack不为空，先处理它
  3.              if (mode < 0 || a.result == null) // 如果是嵌套模式(mode = -1), 或者任务的结果为空，直接清空栈
  4.                  a.cleanStack();
  5.              else
  6.                  a.postComplete(); // 否则，调用postComplete()方法
  7.          }
  8.          if (result != null && stack != null) { // 再处理当前任务
  9.              if (mode < 0) // 嵌套模式，直接返回自身(树 -> 链表，避免过深的递归调用)
  10.                  return this;
  11.              else
  12.                  postComplete(); // 调用postComplete()方法
  13.          }
  14.          return null;
  15.      }

cleanStack()

  1.      final void cleanStack() { // 过滤掉已经死掉的结点(Not isLive)
  2.          for (Completion p = null, q = stack; q != null;) { // q指针从头节点开始，向右移动，s一直执行q的下一个结点，p要么为空，要么指向遍历过的最后一个活着的结点，一旦发现q死掉了，就断开q, 连接p, s
  3.              Completion s = q.next;
  4.              if (q.isLive()) { // 还活着，p指向遍历过的最后一个结点，q向右移动
  5.                  p = q;
  6.                  q = s;
  7.              } else if (p == null) { // 说明第一个结点就是死掉的，cas stack, q指向stack
  8.                  casStack(q, s);
  9.                  q = stack;
  10.              } else { // 否则的话，连接p, s
  11.                  p.next = s;
  12.                  if (p.isLive()) // 再次判断p结点是否还或者(在这期间是否有别的线程改动了)
  13.                      q = s; // 还活着，q继续向右移动
  14.                  else {
  15.                      p = null; // 过期的值，从新开始
  16.                      q = stack;
  17.                  }
  18.              }
  19.          }
  20.      }

如下图

1. 第1个结点是无效结点，更新stack，更新指针

2. 第2个结点是有效结点，更新指针

3. 第3个结点是无效结点，更新指针

4. 第4个结点是有效结点，更新指针

thenApply

  1.      public <U> CompletableFuture<U> thenApply(Function<? super T, ? extends U> fn) {
  2.          return uniApplyStage(null, fn);
  3.      }
  4.  
  5.      public <U> CompletableFuture<U> thenApplyAsync(Function<? super T, ? extends U> fn) {
  6.          return uniApplyStage(asyncPool, fn);
  7.      }
  8.  
  9.      private <V> CompletableFuture<V> uniApplyStage(Executor e, Function<? super T, ? extends V> f) {
  10.          if (f == null)
  11.              throw new NullPointerException();
  12.          CompletableFuture<V> d = new CompletableFuture<V>();
  13.          if (e != null || !d.uniApply(this, f, null)) {
  14.              UniApply<T, V> c = new UniApply<T, V>(e, d, this, f);
  15.              push(c);
  16.              c.tryFire(SYNC);
  17.          }
  18.          return d;
  19.      }
  20.  
  21.      final <S> boolean uniApply(CompletableFuture<S> a, Function<? super S, ? extends T> f, UniApply<S, T> c) {
  22.          Object r;
  23.          Throwable x;
  24.          if (a == null || (r = a.result) == null || f == null)
  25.              return false;
  26.          tryComplete: if (result == null) {
  27.              if (r instanceof AltResult) {
  28.                  if ((x = ((AltResult) r).ex) != null) {
  29.                      completeThrowable(x, r); // 有异常，直接跳出
  30.                      break tryComplete;
  31.                  }
  32.                  r = null;
  33.              }
  34.              try {
  35.                  if (c != null && !c.claim())
  36.                      return false;
  37.                  @SuppressWarnings("unchecked")
  38.                  S s = (S) r;
  39.                  completeValue(f.apply(s));
  40.              } catch (Throwable ex) {
  41.                  completeThrowable(ex);
  42.              }
  43.          }
  44.          return true;
  45.      }
  46.  
  47.      static final class UniApply<T, V> extends UniCompletion<T, V> {
  48.          Function<? super T, ? extends V> fn;
  49.  
  50.          UniApply(Executor executor, CompletableFuture<V> dep, CompletableFuture<T> src,
  51.                  Function<? super T, ? extends V> fn) {
  52.              super(executor, dep, src);
  53.              this.fn = fn;
  54.          }
  55.  
  56.          final CompletableFuture<V> tryFire(int mode) {
  57.              CompletableFuture<V> d;
  58.              CompletableFuture<T> a;
  59.              if ((d = dep) == null || !d.uniApply(a = src, fn, mode > 0 ? null : this))
  60.                  return null;
  61.              dep = null;
  62.              src = null;
  63.              fn = null;
  64.              return d.postFire(a, mode);
  65.          }
  66.      }

一样的套路，thenApply/thenApplyAsync -> uniApplyStage -> uniApply -> tryFire -> postFire

thenAccept

  1.      public CompletableFuture<Void> thenAccept(Consumer<? super T> action) {
  2.          return uniAcceptStage(null, action);
  3.      }
  4.  
  5.      public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action) {
  6.          return uniAcceptStage(asyncPool, action);
  7.      }
  8.  
  9.      private CompletableFuture<Void> uniAcceptStage(Executor e, Consumer<? super T> f) {
  10.          if (f == null)
  11.              throw new NullPointerException();
  12.          CompletableFuture<Void> d = new CompletableFuture<Void>();
  13.          if (e != null || !d.uniAccept(this, f, null)) {
  14.              UniAccept<T> c = new UniAccept<T>(e, d, this, f);
  15.              push(c);
  16.              c.tryFire(SYNC);
  17.          }
  18.          return d;
  19.      }
  20.  
  21.      final <S> boolean uniAccept(CompletableFuture<S> a, Consumer<? super S> f, UniAccept<S> c) {
  22.          Object r;
  23.          Throwable x;
  24.          if (a == null || (r = a.result) == null || f == null)
  25.              return false;
  26.          tryComplete: if (result == null) {
  27.              if (r instanceof AltResult) {
  28.                  if ((x = ((AltResult) r).ex) != null) {
  29.                      completeThrowable(x, r); // 有异常直接跳出
  30.                      break tryComplete;
  31.                  }
  32.                  r = null;
  33.              }
  34.              try {
  35.                  if (c != null && !c.claim())
  36.                      return false;
  37.                  @SuppressWarnings("unchecked")
  38.                  S s = (S) r;
  39.                  f.accept(s);
  40.                  completeNull();
  41.              } catch (Throwable ex) {
  42.                  completeThrowable(ex);
  43.              }
  44.          }
  45.          return true;
  46.      }
  47.  
  48.      static final class UniAccept<T> extends UniCompletion<T, Void> {
  49.          Consumer<? super T> fn;
  50.  
  51.          UniAccept(Executor executor, CompletableFuture<Void> dep, CompletableFuture<T> src, Consumer<? super T> fn) {
  52.              super(executor, dep, src);
  53.              this.fn = fn;
  54.          }
  55.  
  56.          final CompletableFuture<Void> tryFire(int mode) {
  57.              CompletableFuture<Void> d;
  58.              CompletableFuture<T> a;
  59.              if ((d = dep) == null || !d.uniAccept(a = src, fn, mode > 0 ? null : this))
  60.                  return null;
  61.              dep = null;
  62.              src = null;
  63.              fn = null;
  64.              return d.postFire(a, mode);
  65.          }
  66.      }

thenAccept/thenAcceptAsync -> uniAcceptStage -> uniAccept -> tryFire -> postFire

thenRun

  1.      public CompletableFuture<Void> thenRun(Runnable action) {
  2.          return uniRunStage(null, action);
  3.      }
  4.  
  5.      public CompletableFuture<Void> thenRunAsync(Runnable action) {
  6.          return uniRunStage(asyncPool, action);
  7.      }
  8.  
  9.      private CompletableFuture<Void> uniRunStage(Executor e, Runnable f) {
  10.          if (f == null)
  11.              throw new NullPointerException();
  12.          CompletableFuture<Void> d = new CompletableFuture<Void>();
  13.          if (e != null || !d.uniRun(this, f, null)) {
  14.              UniRun<T> c = new UniRun<T>(e, d, this, f);
  15.              push(c);
  16.              c.tryFire(SYNC);
  17.          }
  18.          return d;
  19.      }
  20.  
  21.      final boolean uniRun(CompletableFuture<?> a, Runnable f, UniRun<?> c) {
  22.          Object r;
  23.          Throwable x;
  24.          if (a == null || (r = a.result) == null || f == null)
  25.              return false;
  26.          if (result == null) {
  27.              if (r instanceof AltResult && (x = ((AltResult) r).ex) != null)
  28.                  completeThrowable(x, r);
  29.              else
  30.                  try {
  31.                      if (c != null && !c.claim())
  32.                          return false;
  33.                      f.run();
  34.                      completeNull();
  35.                  } catch (Throwable ex) {
  36.                      completeThrowable(ex);
  37.                  }
  38.          }
  39.          return true;
  40.      }
  41.  
  42.      static final class UniRun<T> extends UniCompletion<T, Void> {
  43.          Runnable fn;
  44.  
  45.          UniRun(Executor executor, CompletableFuture<Void> dep, CompletableFuture<T> src, Runnable fn) {
  46.              super(executor, dep, src);
  47.              this.fn = fn;
  48.          }
  49.  
  50.          final CompletableFuture<Void> tryFire(int mode) {
  51.              CompletableFuture<Void> d;
  52.              CompletableFuture<T> a;
  53.              if ((d = dep) == null || !d.uniRun(a = src, fn, mode > 0 ? null : this))
  54.                  return null;
  55.              dep = null;
  56.              src = null;
  57.              fn = null;
  58.              return d.postFire(a, mode);
  59.          }
  60.      }

thenRun/thenRunAsync -> uniRunStage -> uniRun -> tryFire -> postFire

thenAcceptBoth

thenAcceptBoth

  1.     public <U> CompletableFuture<Void> thenAcceptBoth(CompletionStage<? extends U> other,
  2.             BiConsumer<? super T, ? super U> action) {
  3.         return biAcceptStage(null, other, action);
  4.     }
  5.  
  6.     public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,
  7.             BiConsumer<? super T, ? super U> action) {
  8.         return biAcceptStage(asyncPool, other, action);
  9.     }

biAcceptStage

  1.     private <U> CompletableFuture<Void> biAcceptStage(Executor e, CompletionStage<U> o,
  2.             BiConsumer<? super T, ? super U> f) {
  3.         CompletableFuture<U> b;
  4.         if (f == null || (b = o.toCompletableFuture()) == null)
  5.             throw new NullPointerException();
  6.         CompletableFuture<Void> d = new CompletableFuture<Void>();
  7.         if (e != null || !d.biAccept(this, b, f, null)) {
  8.             BiAccept<T, U> c = new BiAccept<T, U>(e, d, this, b, f);
  9.             bipush(b, c);
  10.             c.tryFire(SYNC);
  11.         }
  12.         return d;
  13.     }

bipush

  1.      final void bipush(CompletableFuture<?> b, BiCompletion<?, ?, ?> c) {
  2.          if (c != null) {
  3.              Object r;
  4.              while ((r = result) == null && !tryPushStack(c)) // a的result还没准备好，c压入栈
  5.                  lazySetNext(c, null); // 失败重置c的next域
  6.              if (b != null && b != this && b.result == null) { // b的result也还没准备好
  7.                  Completion q = (r != null) ? c : new CoCompletion(c); // 根据a的result决定是否构建CoCompletion, 如果a未结束，则构建一个CoCompletion, CoCompletion最后调用的也是BiCompletion的tryFire
  8.                  while (b.result == null && !b.tryPushStack(q)) // 将q压入栈
  9.                      lazySetNext(q, null); // 失败重置q的next域
  10.              }
  11.          }
  12.      }

CoCompletion

  1.      static final class CoCompletion extends Completion {
  2.          BiCompletion<?, ?, ?> base;
  3.  
  4.          CoCompletion(BiCompletion<?, ?, ?> base) {
  5.              this.base = base;
  6.          }
  7.  
  8.          final CompletableFuture<?> tryFire(int mode) {
  9.              BiCompletion<?, ?, ?> c;
  10.              CompletableFuture<?> d;
  11.              if ((c = base) == null || (d = c.tryFire(mode)) == null) // 调用的还是BiCompletion的tryFire方法
  12.                  return null;
  13.              base = null;
  14.              return d;
  15.          }
  16.  
  17.          final boolean isLive() {
  18.              BiCompletion<?, ?, ?> c;
  19.              return (c = base) != null && c.dep != null;
  20.          }
  21.      }

biAccept

  1.      final <R, S> boolean biAccept(CompletableFuture<R> a, CompletableFuture<S> b, BiConsumer<? super R, ? super S> f,
  2.              BiAccept<R, S> c) {
  3.          Object r, s;
  4.          Throwable x;
  5.          if (a == null || (r = a.result) == null || b == null || (s = b.result) == null || f == null)
  6.              return false; // a和b都完成了，才会往下走
  7.          tryComplete: if (result == null) {
  8.              if (r instanceof AltResult) {
  9.                  if ((x = ((AltResult) r).ex) != null) { // a的异常检查
  10.                      completeThrowable(x, r);
  11.                      break tryComplete;
  12.                  }
  13.                  r = null;
  14.              }
  15.              if (s instanceof AltResult) {
  16.                  if ((x = ((AltResult) s).ex) != null) { // b的异常检查
  17.                      completeThrowable(x, s);
  18.                      break tryComplete;
  19.                  }
  20.                  s = null;
  21.              }
  22.              try {
  23.                  if (c != null && !c.claim())
  24.                      return false;
  25.                  @SuppressWarnings("unchecked")
  26.                  R rr = (R) r;
  27.                  @SuppressWarnings("unchecked")
  28.                  S ss = (S) s;
  29.                  f.accept(rr, ss); // 执行任务
  30.                  completeNull();
  31.              } catch (Throwable ex) {
  32.                  completeThrowable(ex);
  33.              }
  34.          }
  35.          return true;
  36.      }

BiAccept

  1.      static final class BiAccept<T, U> extends BiCompletion<T, U, Void> {
  2.          BiConsumer<? super T, ? super U> fn;
  3.  
  4.          BiAccept(Executor executor, CompletableFuture<Void> dep, CompletableFuture<T> src, CompletableFuture<U> snd,
  5.                  BiConsumer<? super T, ? super U> fn) {
  6.              super(executor, dep, src, snd);
  7.              this.fn = fn;
  8.          }
  9.  
  10.          final CompletableFuture<Void> tryFire(int mode) {
  11.              CompletableFuture<Void> d;
  12.              CompletableFuture<T> a;
  13.              CompletableFuture<U> b;
  14.              if ((d = dep) == null || !d.biAccept(a = src, b = snd, fn, mode > 0 ? null : this))
  15.                  return null;
  16.              dep = null;
  17.              src = null;
  18.              snd = null;
  19.              fn = null;
  20.              return d.postFire(a, b, mode);
  21.          }
  22.      }
  23.  
  24.      abstract static class BiCompletion<T, U, V> extends UniCompletion<T, V> {
  25.          CompletableFuture<U> snd; // second source for action
  26.  
  27.          BiCompletion(Executor executor, CompletableFuture<V> dep, CompletableFuture<T> src, CompletableFuture<U> snd) {
  28.              super(executor, dep, src);
  29.              this.snd = snd;
  30.          }
  31.      }

thenAcceptBoth/thenAcceptBothAsync -> biAcceptStage -> biAccept -> tryFire -> postFire

acceptEither

  1.      public CompletableFuture<Void> acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action) {
  2.          return orAcceptStage(null, other, action);
  3.      }
  4.  
  5.      public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action) {
  6.          return orAcceptStage(asyncPool, other, action);
  7.      }
  8.  
  9.      private <U extends T> CompletableFuture<Void> orAcceptStage(Executor e, CompletionStage<U> o,
  10.              Consumer<? super T> f) {
  11.          CompletableFuture<U> b;
  12.          if (f == null || (b = o.toCompletableFuture()) == null)
  13.              throw new NullPointerException();
  14.          CompletableFuture<Void> d = new CompletableFuture<Void>();
  15.          if (e != null || !d.orAccept(this, b, f, null)) {
  16.              OrAccept<T, U> c = new OrAccept<T, U>(e, d, this, b, f);
  17.              orpush(b, c);
  18.              c.tryFire(SYNC);
  19.          }
  20.          return d;
  21.      }
  22.  
  23.      final <R, S extends R> boolean orAccept(CompletableFuture<R> a, CompletableFuture<S> b, Consumer<? super R> f,
  24.              OrAccept<R, S> c) {
  25.          Object r;
  26.          Throwable x;
  27.          if (a == null || b == null || ((r = a.result) == null && (r = b.result) == null) || f == null)
  28.              return false; // a和b有一个完成了就往下走
  29.          tryComplete: if (result == null) {
  30.              try {
  31.                  if (c != null && !c.claim())
  32.                      return false;
  33.                  if (r instanceof AltResult) { // 异常
  34.                      if ((x = ((AltResult) r).ex) != null) {
  35.                          completeThrowable(x, r);
  36.                          break tryComplete;
  37.                      }
  38.                      r = null;
  39.                  }
  40.                  @SuppressWarnings("unchecked")
  41.                  R rr = (R) r;
  42.                  f.accept(rr); // 执行
  43.                  completeNull();
  44.              } catch (Throwable ex) {
  45.                  completeThrowable(ex);
  46.              }
  47.          }
  48.          return true;
  49.      }
  50.  
  51.      static final class OrAccept<T, U extends T> extends BiCompletion<T, U, Void> {
  52.          Consumer<? super T> fn;
  53.  
  54.          OrAccept(Executor executor, CompletableFuture<Void> dep, CompletableFuture<T> src, CompletableFuture<U> snd,
  55.                  Consumer<? super T> fn) {
  56.              super(executor, dep, src, snd);
  57.              this.fn = fn;
  58.          }
  59.  
  60.          final CompletableFuture<Void> tryFire(int mode) {
  61.              CompletableFuture<Void> d;
  62.              CompletableFuture<T> a;
  63.              CompletableFuture<U> b;
  64.              if ((d = dep) == null || !d.orAccept(a = src, b = snd, fn, mode > 0 ? null : this))
  65.                  return null;
  66.              dep = null;
  67.              src = null;
  68.              snd = null;
  69.              fn = null;
  70.              return d.postFire(a, b, mode);
  71.          }
  72.      }
  73.  
  74.      final void orpush(CompletableFuture<?> b, BiCompletion<?, ?, ?> c) {
  75.          if (c != null) {
  76.              while ((b == null || b.result == null) && result == null) { // a和b的result都没好，才会考虑入栈
  77.                  if (tryPushStack(c)) { // 先入a的栈
  78.                      if (b != null && b != this && b.result == null) { // 入a的栈成功，b的result还没好
  79.                          Completion q = new CoCompletion(c); // a还未结束，用c构建CoCompletion
  80.                          while (result == null && b.result == null && !b.tryPushStack(q)) // 再次判断，a和b的result都没好，才会考虑入栈
  81.                              lazySetNext(q, null); // 失败置空q的next域
  82.                      }
  83.                      break;
  84.                  }
  85.                  lazySetNext(c, null); // 失败置空c的next域
  86.              }
  87.          }
  88.      }

acceptEither/acceptEitherAsync -> orAcceptStage -> orAccept -> tryFire -> postFire

allOf

  1.      public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs) {
  2.          return andTree(cfs, 0, cfs.length - 1);
  3.      }
  4.  
  5.      static CompletableFuture<Void> andTree(CompletableFuture<?>[] cfs, int lo, int hi) { // 将一个数组构建成一棵树，二叉树，动态规划
  6.          CompletableFuture<Void> d = new CompletableFuture<Void>();
  7.          if (lo > hi) // empty
  8.              d.result = NIL;
  9.          else {
  10.              CompletableFuture<?> a, b;
  11.              int mid = (lo + hi) >>> 1;
  12.              if ((a = (lo == mid ? cfs[lo] : andTree(cfs, lo, mid))) == null
  13.                      || (b = (lo == hi ? a : (hi == mid + 1) ? cfs[hi] : andTree(cfs, mid + 1, hi))) == null)
  14.                  throw new NullPointerException();
  15.              if (!d.biRelay(a, b)) {
  16.                  BiRelay<?, ?> c = new BiRelay<>(d, a, b);
  17.                  a.bipush(b, c); // both
  18.                  c.tryFire(SYNC);
  19.              }
  20.          }
  21.          return d;
  22.      }
  23.  
  24.      static final class BiRelay<T, U> extends BiCompletion<T, U, Void> { // for And
  25.          BiRelay(CompletableFuture<Void> dep, CompletableFuture<T> src, CompletableFuture<U> snd) {
  26.              super(null, dep, src, snd);
  27.          }
  28.  
  29.          final CompletableFuture<Void> tryFire(int mode) {
  30.              CompletableFuture<Void> d;
  31.              CompletableFuture<T> a;
  32.              CompletableFuture<U> b;
  33.              if ((d = dep) == null || !d.biRelay(a = src, b = snd))
  34.                  return null;
  35.              src = null;
  36.              snd = null;
  37.              dep = null;
  38.              return d.postFire(a, b, mode);
  39.          }
  40.      }
  41.  
  42.      boolean biRelay(CompletableFuture<?> a, CompletableFuture<?> b) {
  43.          Object r, s;
  44.          Throwable x;
  45.          if (a == null || (r = a.result) == null || b == null || (s = b.result) == null)
  46.              return false; // a和b都结束了才往下执行
  47.          if (result == null) {
  48.              if (r instanceof AltResult && (x = ((AltResult) r).ex) != null)
  49.                  completeThrowable(x, r);
  50.              else if (s instanceof AltResult && (x = ((AltResult) s).ex) != null)
  51.                  completeThrowable(x, s);
  52.              else
  53.                  completeNull(); // 辅助结点，什么都不做
  54.          }
  55.          return true;
  56.      }

allOf -> andTree -> biRelay -> tryFire -> postFire

anyOf

  1.      public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs) {
  2.          return orTree(cfs, 0, cfs.length - 1);
  3.      }
  4.  
  5.      static CompletableFuture<Object> orTree(CompletableFuture<?>[] cfs, int lo, int hi) { // 将一个数组构建成一棵树，二叉树，动态规划
  6.          CompletableFuture<Object> d = new CompletableFuture<Object>();
  7.          if (lo <= hi) {
  8.              CompletableFuture<?> a, b;
  9.              int mid = (lo + hi) >>> 1;
  10.              if ((a = (lo == mid ? cfs[lo] : orTree(cfs, lo, mid))) == null
  11.                      || (b = (lo == hi ? a : (hi == mid + 1) ? cfs[hi] : orTree(cfs, mid + 1, hi))) == null)
  12.                  throw new NullPointerException();
  13.              if (!d.orRelay(a, b)) {
  14.                  OrRelay<?, ?> c = new OrRelay<>(d, a, b);
  15.                  a.orpush(b, c);
  16.                  c.tryFire(SYNC);
  17.              }
  18.          }
  19.          return d;
  20.      }
  21.  
  22.      static final class OrRelay<T, U> extends BiCompletion<T, U, Object> { // for Or
  23.          OrRelay(CompletableFuture<Object> dep, CompletableFuture<T> src, CompletableFuture<U> snd) {
  24.              super(null, dep, src, snd);
  25.          }
  26.  
  27.          final CompletableFuture<Object> tryFire(int mode) {
  28.              CompletableFuture<Object> d;
  29.              CompletableFuture<T> a;
  30.              CompletableFuture<U> b;
  31.              if ((d = dep) == null || !d.orRelay(a = src, b = snd))
  32.                  return null;
  33.              src = null;
  34.              snd = null;
  35.              dep = null;
  36.              return d.postFire(a, b, mode);
  37.          }
  38.      }
  39.  
  40.      final boolean orRelay(CompletableFuture<?> a, CompletableFuture<?> b) {
  41.          Object r;
  42.          if (a == null || b == null || ((r = a.result) == null && (r = b.result) == null))
  43.              return false; // a和b有一个结束就往下进行
  44.          if (result == null)
  45.              completeRelay(r);
  46.          return true;
  47.      }

anyOf -> orTree -> orRelay -> tryFire -> postFire

数组构建树

allOf和anyOf都用到了数组构建成树的策略。

假设有一个任务Z(虚拟的，什么都不做)，依赖一组任务[A, B, C, D, E, F, G, H]

对于allOf, 当这组任务都完成时，才会执行Z；对于anyOf, 当这组任务中有任何一个完成，就执行任务Z。

如果这组任务是数组结构或者链表结构，我们该如何解决呢？遍历数组或者是链表，当任务都完成或者有一个完成时，就执行Z，需要不停地遍历，这是轮询的方法，不合适。

整个基调是回调，是指，当一个任务完成时，会接着执行所有依赖于它的任务。

作为一个数组或者链表，该如何应用回调呢？谁在先，谁在后呢？因为不知道哪个任务会先完成，所以没法确定次序。而且这组任务之间也不应该相互依赖，它们只不过都是被Z依赖。

如果这组任务只有一个的话，那就演变成了X.thenXXX(Z), 如果这组任务有两个的话，allOf -> Both，anyOf -> Either

如果Z依赖Z1,Z2两个个任务，Z1和Z2依赖Z11,Z12和Z21,Z22四个任务，依次类推，当虚拟的任务的个数达到真实任务的个数的一半时，就让虚拟任务监听真实的任务，动态规划加二叉树，时间复杂度也只是logn级别的。

  1.      static String array2Tree(String[] cfs, int lo, int hi) {
  2.          String d = new String(cfs[lo] + cfs[hi]);
  3.          if (lo <= hi) {
  4.              String a, b;
  5.              int mid = (lo + hi) >>> 1; // 二分
  6.              if (lo == mid) { // a作为左半部分的的结果
  7.                  a = cfs[lo]; // 当只有不超过两个元素时，a直接取第一个值
  8.              } else {
  9.                  a = array2Tree(cfs, lo, mid);
  10.              }
  11.              if (lo == hi) { // 当只有一个元素的时候，b取a的值
  12.                  b = a;
  13.              } else {
  14.                  if (hi == mid + 1) { // 右半部分只有两个元素时，b取第二个元素的值
  15.                      b = cfs[hi];
  16.                  } else {
  17.                      b = array2Tree(cfs, mid + 1, hi);
  18.                  }
  19.              }
  20.              if (a == null || b == null) {
  21.                  throw new NullPointerException();
  22.              }
  23.              System.out.println("[" + a + "][" + b + "]->[" + d + "]");
  24.          }
  25.          return d;
  26.      }

Console

  1. [A][B]->[AB]
  2. [C][D]->[CD]
  3. [AB][CD]->[AD]
  4. [E][F]->[EF]
  5. [G][H]->[GH]
  6. [EF][GH]->[EH]
  7. [AD][EH]->[AH]

如下图

对于allOf, Z只要保证Z1和Z2都完成了就行，Z1和Z2分别保证Z11,Z12 和 Z21,Z22都完成了就像，而Z11,Z12,Z21,Z22则分别保证了A-H任务都完成。

对应anyOf, Z 只要保证Z1和Z2有一个完成了就像，Z1和Z2联合保证了Z11,Z12,Z21,Z22这4个任务只要有一个完成了就行，同理，Z11,Z12,Z21,Z22则联合保证了A-H中有一个任务完成了就行。

然后，Z就可以执行了，其实Z什么也没做，只是从这组任务里得出一个结果。

行文至此结束。

尊重他人的劳动，转载请注明出处：http://www.cnblogs.com/aniao/p/aniao_cf.html

  1.  

【JUC源码解析】CompletableFuture的更多相关文章

  1. 【JUC源码解析】ScheduledThreadPoolExecutor

    简介 它是一个线程池执行器(ThreadPoolExecutor),在给定的延迟(delay)后执行.在多线程或者对灵活性有要求的环境下,要优于java.util.Timer. 提交的任务在执行之前支 ...

  2. 【JUC源码解析】SynchronousQueue

    简介 SynchronousQueue是一种特殊的阻塞队列,该队列没有容量. [存数据线程]到达队列后,若发现没有[取数据线程]在此等待,则[存数据线程]便入队等待,直到有[取数据线程]来取数据,并释 ...

  3. 【JUC源码解析】ForkJoinPool

    简介 ForkJoin 框架,另一种风格的线程池(相比于ThreadPoolExecutor),采用分治算法,工作密取策略,极大地提高了并行性.对于那种大任务分割小任务的场景(分治)尤其有用. 框架图 ...

  4. 【JUC源码解析】DelayQueue

    简介 基于优先级队列,以过期时间作为排序的基准,剩余时间最少的元素排在队首.只有过期的元素才能出队,在此之前,线程等待. 源码解析 属性 private final transient Reentra ...

  5. 【JUC源码解析】CyclicBarrier

    简介 CyclicBarrier,一个同步器,允许多个线程相互等待,直到达到一个公共屏障点. 概述 CyclicBarrier支持一个可选的 Runnable 命令,在一组线程中的最后一个线程到达之后 ...

  6. 【JUC源码解析】ConcurrentLinkedQueue

    简介 ConcurrentLinkedQueue是一个基于链表结点的无界线程安全队列. 概述 队列顺序,为FIFO(first-in-first-out):队首元素,是当前排队时间最长的:队尾元素,当 ...

  7. 【JUC源码解析】Exchanger

    简介 Exchanger,并发工具类,用于线程间的数据交换. 使用 两个线程,两个缓冲区,一个线程往一个缓冲区里面填数据,另一个线程从另一个缓冲区里面取数据.当填数据的线程将缓冲区填满时,或者取数据的 ...

  8. Jdk1.6 JUC源码解析(12)-ArrayBlockingQueue

    功能简介: ArrayBlockingQueue是一种基于数组实现的有界的阻塞队列.队列中的元素遵循先入先出(FIFO)的规则.新元素插入到队列的尾部,从队列头部取出元素. 和普通队列有所不同,该队列 ...

  9. Jdk1.6 JUC源码解析(13)-LinkedBlockingQueue

    功能简介: LinkedBlockingQueue是一种基于单向链表实现的有界的(可选的,不指定默认int最大值)阻塞队列.队列中的元素遵循先入先出 (FIFO)的规则.新元素插入到队列的尾部,从队列 ...

随机推荐

  1. dubbo-admin管理控制台的安装部署(最简单)

    Dubbo-admin最简单的安装部署,十分钟就能搞定! 网上找的安装教程虽说详细,但是就是因为详细操作起来而显得繁琐.今天,我帮大家跳过这些繁琐的步骤,简单快捷的安装部署dubbo-admin. 1 ...

  2. Scala学习笔记2 （带着问题学习， 逐渐扩展。理解吃透scala.）

    问题: 把 文本字符串"[1, 2, 3, 4, 5]" 转换成一个数组. 答案: val x = "[1, 2, 3, 4, 5]" val y =x sli ...

  3. [20171225]RMAN-06808: SECTION SIZE cannot be used when piece limit is in effect.txt

    [20171225]RMAN-06808: SECTION SIZE cannot be used when piece limit is in effect.txt --//朋友拿我的一些例子来测试 ...

  4. Sql Server 判断字符串是否可以转数字

    主要是在sql server的内置系统函数ISNUMERIC的基础上,将例外的“+”.“-”.“$”等也进行判断. CREATE FUNCTION [dbo].[fn_IsNumberic]( @st ...

  5. c# 百度地图api APP SN校验失败

    在使用c#调用百度地图Web服务api遇到的签名(sn校验)问题,在此记录一下,(ip白名单校验的请忽略) 1.首先获取ak与sk,这个两个东西可以从控制台中获取到 2.在这个地址:sn签名算法,里面 ...

  6. Sublime Text 3 注册码激活码被移除的解决办法

    新版的sublime text3中加入了验证功能,之前成功注册的也被移除了,在网上搜索的验证码要么已经失效要么已经被封,少数几个正常的注册输入进去注册成功后几分钟之内这个注册码就会被莫名其妙的被移除. ...

  7. table表格(笔记)

    <table class="table table-hover2 pick_carTable"> <thead> <tr class="bl ...

  8. C++中int型与string型互相转换（转）

    http://greatverve.cnblogs.com/archive/2012/10/24/cpp-int-string.html 本以为这么多年C#经验,学个C++没多难,现在发现错了.C++ ...

  9. Weblogic读不到Word文件

    之前遇到一导出word文件的需求,我的做法是把对应导出内容放到一个word文件中,把其中变化的内容作为变量,然后把该word文件放在WEB-INF目录下用来作为模板.在导出时通过ServletCont ...

  10. BZOJ1006:[HNOI2008]神奇的国度(弦图染色)

    Description K国是一个热衷三角形的国度,连人的交往也只喜欢三角原则.他们认为三角关系:即AB相互认识,BC相互认识,CA相互认识,是简洁高效的. 为了巩固三角关系,K国禁止四边关系,五边关 ...