CompletableFuture运行流程源码详解

最新推荐文章于 2024-08-06 16:48:59 发布

编号94530

最新推荐文章于 2024-08-06 16:48:59 发布

阅读量603

点赞数

分类专栏： java 源码分析文章标签： java 编程语言并发编程多线程

本文链接：https://blog.csdn.net/shiyan719902675/article/details/107663783

版权

java 同时被 2 个专栏收录

13 篇文章 1 订阅

订阅专栏

源码分析

11 篇文章 1 订阅

订阅专栏

1. 背景

CompletableFuture用起来着实舒服，代码一写，异步跑起来，时间缩短了不少（一个IO任务单线程40多分钟，用上多线程CompletableFuture，直接变成7分钟了）。代码是用起来了，很舒服，但是里面的原理，想必有些大兄弟还不怎么清楚。今天就来一步步分析一下运行流程。

2. 上代码

CompletableFuture可以通过构造函数或者提供的方法构造一个CompletableFuture对象。我们今天就以CompletableFuture#supplyAsync方法来讲解。直接传值构造或者CompletableFuture#runAsync都少了一些步骤。一个少了通过方法构造，少了异步执行过程，另一个没有返回值。（最终运行逻辑都是一样的）

2.1 创建CompletableFuture

    public static void testCompletableFuture() {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "test CompletableFuture.");
    }

我们直接通过类提供的方法来创建一个CompletableFuture。我们直接点进CompletableFuture#supplyAsync，看看方法里面到底有什么东西。

    static <U> CompletableFuture<U> asyncSupplyStage(Executor e,
                                                     Supplier<U> f) {
        if (f == null) throw new NullPointerException();
      	// 创建了一个CompletableFuture， 丢尽了AsyncSupply中
        CompletableFuture<U> d = new CompletableFuture<U>();
      	// 把新创建的CompletableFuture和Supplier丢到构建AsyncSupply，构建AsyncSupply任务
        e.execute(new AsyncSupply<U>(d, f));
      	// 直接将CompletableFuture对象返回了。 
        // 在线程池中执行AsyncSupply任务
        return d;
    }

看代码有两个点需要我们注意，1. 任务丢进线程池，核心运行代码肯定在AsuncSupply#run中。2. CompletableFuture丢进线程池后直接返回，这是一个异步任务。

接下来我们直接看AsyncSupply是什么

2.1.1 AsyncSupply是什么

屁话不多说，直接上代码。

    // 继承ForkJoinTask，也就是说AsyncSupply是ForkJoinTask。
		// 个人理解：这继承ForkJoinTask，完全是为了兼容，用上forkJoinPool
		static final class AsyncSupply<T> extends ForkJoinTask<Void>
            implements Runnable, AsynchronousCompletionTask {
        CompletableFuture<T> dep; Supplier<T> fn;
        AsyncSupply(CompletableFuture<T> dep, Supplier<T> fn) {
            this.dep = dep; this.fn = fn;
        }

        public final Void getRawResult() { return null; }
        public final void setRawResult(Void v) {}
        public final boolean exec() { run(); return true; }

        public void run() {
            CompletableFuture<T> d; Supplier<T> f;
            if ((d = dep) != null && (f = fn) != null) {
                dep = null; fn = null;
              	// 传递进来的是一个new CompletableFuture， 
                // d.result == null 说明当前这个Future还未运行或者未运行完
                if (d.result == null) {
                    try {
                      	// 运行Supplier
                        d.completeValue(f.get());
                    } catch (Throwable ex) {
                        d.completeThrowable(ex);
                    }
                }
              	// 看名字，结束后运行什么。得分析分析
                d.postComplete();
            }
        }
    }

我们看到这个逻辑没有什么复杂的，把AsyncSupply封装成了ForkJoinTask。(个人认为是为了用上ForkJoinPool，毕竟ForkJoinPool有任务窃取，又能快上不少，速度才是硬道理。哈哈！)。

2.1.1.1 d.completeValue(f.get())

屁话少说，看代码。

    final boolean completeValue(T t) {
        return UNSAFE.compareAndSwapObject(this, RESULT, null,
                                           (t == null) ? NIL : t);
    }

代码很简单，没有罗里吧嗦，就是通过CAS把supplier结果设置给Result。

2.1.1.2 d.postComplete()

    final void postComplete() {
        /*
         * On each step, variable f holds current dependents to pop
         * and run.  It is extended along only one path at a time,
         * pushing others to avoid unbounded recursion.
         */
      	// this指的就是运行完supplier后的CompletableFuture
        CompletableFuture<?> f = this; Completion h;
        while ((h = f.stack) != null ||
               (f != this && (h = (f = this).stack) != null)) {
            CompletableFuture<?> d; Completion t;
          	// 通过cas, 把当前运行的CompletableFuture的stack中的下一个Completion赋值给t
            if (f.casStack(h, t = h.next)) {
                if (t != null) {
                    if (f != this) {
                        pushStack(h);
                        continue;
                    }
                    h.next = null;    // detach
                }
              	// 执行Completion中的tryFire方法。如果结果不为空，则返回
                f = (d = h.tryFire(NESTED)) == null ? this : d;
            }
        }
    }

看到这，目前对我们来说就可以了。留下了2个悬念。分别是：

Completion是什么？
Completion#tryFire是干嘛的？

这两个问题，看似两个，实则一个，弄懂Completion是什么，就可以知道Completion#tryFire是什么。

看到现在，我们则对CompletableFuture的流程有一个大概了解，砍起来是这样的。如下图。
Completable初始化

2.2 CompletableFuture call

我们创建了CompletableFuture，接下来有两种使用方式，分别是：

代码1：

CompletableFuture<Void> futureChain = CompletableFuture.supplyAsync(() -> "test CompletableFuture.")
  .thenAccept(System.out::println)
  .thenRun(() -> {});

代码2：

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "test CompletableFuture.");
future.thenAccept(System.out::println);
future.thenRun(() -> {});

代码3：

CompletableFuture<Void> futureChain = CompletableFuture.supplyAsync(() -> "test CompletableFuture.")
  .thenAccept(System.out::println)
  .thenRun(() -> {});

futureChain.thenRun(() -> { });

代码1和代码2两种方式看着相似，但意义完全不一样。代码1是基于每次返回的CompletableFuture在调用，而代码2则是基于创建的future在调用。而这两种方式合起来则构成了代码3。为了弄懂代码3，我们则从1，2开始分析。

2.2.1 代码1

进入thenAccept方法看看具体的代码逻辑。

private CompletableFuture<Void> uniAcceptStage(Executor e,
                                               Consumer<? super T> f) {
  if (f == null) throw new NullPointerException();
  // 新创建了一个CompletableFuture
  CompletableFuture<Void> d = new CompletableFuture<Void>();
  // executor 传入的是null, d.uniaccept判断驱动thenAccept的CompletableFuture是否运行完/是否运行
  if (e != null || !d.uniAccept(this, f, null)) {
    // 用新创建的CompletableFuture和驱动thenAccept的CompletableFuture构建一个UniAccept
    UniAccept<T> c = new UniAccept<T>(e, d, this, f);
    // 放入栈中
    // 注意： 此栈是第一步执行完，返回的CompletableFuture
    push(c);
    c.tryFire(SYNC);
  }
  return d;
}

此方法就是判断当前CompletableFuture是否已经运行，如果美云销，则放入栈中。（此栈是supplyAsync返回的CompletableFuture）

c.tryFire(SYNC)，从这个我们大概可以看出，c应该是Completion类型，否则怎么会有tryFire方法呢？我们进入UniAccept，看看这个方法是什么东西。

2.2.1.1 UniAccept

// 继承UniCompletion，点进去发现是继承CompletableFuture
// 我们可以看得出来，具体逻辑是把每个操作都封装成了Completion，放入了栈中
static final class UniAccept<T> extends UniCompletion<T,Void> {
  Consumer<? super T> fn;
  // dep: 新创建的CompletableFuture
  // src: 驱动thenAccept的CompletableFuture
  UniAccept(Executor executor, CompletableFuture<Void> dep,
            CompletableFuture<T> src, Consumer<? super T> fn) {
   	
    super(executor, dep, src); this.fn = fn;
  }
  final CompletableFuture<Void> tryFire(int mode) {
    CompletableFuture<Void> d; CompletableFuture<T> a;
    if ((d = dep) == null ||
        !d.uniAccept(a = src, fn, mode > 0 ? null : this))
      return null;
    dep = null; src = null; fn = null;
    // 尝试驱动下一个Completion。代码合前面相似
    return d.postFire(a, mode);
  }
}

从这，我们可以大概看懂什么是Completion了。即把每个Operation都封装成了Completion，然后放入到栈中，然后执行。但是这个栈还是有点不同的。

看完代码1部分，我们对CompletableFuture的认知应该是这样的，如下图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img- CompletableFuture call

我们暂且认知就是这的，接下来我们看代码2，看代码2是如何实现的。

2.2.2 代码2

private CompletableFuture<Void> uniAcceptStage(Executor e,
                                               Consumer<? super T> f) {
  if (f == null) throw new NullPointerException();
  CompletableFuture<Void> d = new CompletableFuture<Void>();
  if (e != null || !d.uniAccept(this, f, null)) {
    UniAccept<T> c = new UniAccept<T>(e, d, this, f);
    push(c);
    c.tryFire(SYNC);
  }
  return d;
}