CompletionStage及其实现CompletableFuture源码分析

概述

CompletionStage直译是完成阶段，如果你发现你有这么一个需求：一个大的任务可以拆分成多个子任务，并且子任务之间有明显的先后顺序或者一个子任务依赖另一个子任务完成的结果时，那么CompletionStage是一个不错的选择，有点像聚合任务的特点，但Completion可以实现比聚会任务复杂得多的任务交互，CompletionStage就是实现了将一个大任务分成若个子任务，这些子任务基于一定的并行、串行组合形成任务的不同阶段，CompletionStage接口实现了对这些子任务之间的关系定义，接口方法较多如下：

CompletionStage接口的方法虽然方法很多但不难发现有规律可循，因为CompletionState定义的方法名以及方法参数大量使用了jdk基本的函数式接口，简单说明几个基本的函数式接口如下：

• Supplier:产出型函数，该函数式接口将返回一个结果，内部定义了一个 T get()方法；
• Consumer:消耗性函数，接受并消费一个参数，内部定义了一个accept(T t)方法；
• Function:即消耗又产出型函数，接受并消费一个参数同时返回一个结果，内部定义了一个R apply(T t)方法;
• BiConsumer:消费性函数，接受并消费两个参数，内部定义了一个void accept(T t, U u)方法;
• BiFunction:即消耗又产出型函数，接受并消费两个参数并返回一个结果，内部定义了一个R apply(T t, U u)方法;

观察CompletionStage接口的方法发现基本都是由then、apply、async、accept、run、combine、both、either、after、compose、when、handle等关键词组合而成,这些关键字可以理解如下：

• then：表示阶段先后顺序，即一个阶段等待另一个阶段完成
• apply：和上面Function一样，表示消费一个参数并提供一个结果
• async：异步标志，即阶段任务的执行相对于当前线程是同步还是异步
• accept：和上面Consumer的accept方法一样，表示消费一个参数
• run：既不消费也不铲除，同Runnable接口含义
• combine：合并两个阶段结果并返回新的阶段
• both：表示二者条件都成立再做其它事
• either：表示二者之一条件成立再做其它事，对应both
• after:表先后顺序，一个任务发生在另一个任务之后,和then相似
• compose：表示根据已有结果生成新的结果，同上面的Function,细看compose的参数和thenApply有区别，具体区别再下面陈述
• when：等同于whenComplete,当前阶段正常完成或异常完成时执行BiConsumer动作
• handle：当前阶段正常完成或异常完成后触发一个BiFunction动作

此外观察所有接口参数不难发现参数仅包含以下三种：

• 函数式接口：Runnable、Consumer、Function、BiConsumer、BiFunction
• 另一个CompletionStage
• Executor
  因此该接口提供的所有方法可以总结成一句话：当前阶段完成(分为正常完成或异常完成)后，根据当前阶段的返回的结果(分有结果或无结果)去执行(分同步或异步，其中异步可以基于自定义的执行器)入参中的函数式接口并返回一个新的CompletionStage

CompletionStage接口方法说明bai

	/*
	*同步执行：这里的同步执行分两种可能
	*	1.调用方法时当前阶段还没有完成，则同步执行表示由当前阶段任务对应线程同步执行
	*	2.调用方法时当前阶段已经完成，则同步执行表示由调用方法线程执行
	*异步执行：这里异步执行表示将任务提交到线程池由线程池分配线程执行
	*执行器：调用方法时可以使用指定的执行器执行任务
	*/

    //当前阶段正常完成后其结果作为fn（Function）的入参同步执行fn并返回一个新的CompletionStage
    public <U> CompletionStage<U> thenApply(Function<? super T,? extends U> fn);

    //同上，区别在于异步执行fn
    public <U> CompletionStage<U> thenApplyAsync(Function<? super T,? extends U> fn);

    //同上，区别在于使用指定执行器异步执行
    public <U> CompletionStage<U> thenApplyAsync(Function<? super T,? extends U> fn,Executor executor);

    //当前阶段正常完成后其结果作为action（Consumer）的入参同步执行action并返回一个新的CompletionStage
    //与thenApply相比，返回的新CompletionStage泛型参数为Void
    public CompletionStage<Void> thenAccept(Consumer<? super T> action);

    //同上，区别在于异步执行fn
    public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action);

    //同上，区别在于使用指定执行器异步执行
    public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action, Executor executor);
    
    //当前阶段正常完成后同步执行指定的action，不需要当前阶段执行结果，任务也不返回结果
    public CompletionStage<Void> thenRun(Runnable action);

    //同上，区别在于异步执行fn
    public CompletionStage<Void> thenRunAsync(Runnable action);
    
    //同上，区别在于使用指定执行器异步执行
    public CompletionStage<Void> thenRunAsync(Runnable action, Executor executor);

    //当前阶段和参数other阶段同时正常完成后其二者的结果作为fn的入参同步执行fn并返回一个新的CompletionStage
    public <U,V> CompletionStage<V> thenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);

    //同上，区别在于异步执行fn
    public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);

    //同上，只是在指定的执行器中异步执行
    public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V>  fn,Executor executor);

    //当前阶段和入参中的other阶段均正常完成后，二者的结果作为action的入参同步执行action并返回新的CompletionStage
    public <U> CompletionStage<Void> thenAcceptBoth(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);

    //同上，只是异步执行action
    public <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T, ? super U> action);

    //同上只是在执行的执行器中异步执行action
    public <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action,Executor executor);

    //当前阶段和入参中的other阶段均正常完成后同步执行action
    public CompletionStage<Void> runAfterBoth(CompletionStage<?> other, Runnable action);
    //同上，异步执行
    public CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action);

    //通常，再指定的执行器中异步执行
    public CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action,Executor executor);
    
    //当前阶段或入参中的other阶段二者只要有一个阶段正常完成则其结果作为fn的入参同步执行fn并返回一个新的阶段
    public <U> CompletionStage<U> applyToEither(CompletionStage<? extends T> other,Function<? super T, U> fn);

    //同上，异步执行
    public <U> CompletionStage<U> applyToEitherAsync (CompletionStage<? extends T> other, Function<? super T, U> fn);

    //同上，再指定的执行中异步执行
    public <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn,
         Executor executor);

    //当前阶段或入参中的other阶段二者之一正常完成时其结果将作为action入参同步执行并返回一个不带结果的新的阶段
    public CompletionStage<Void> acceptEither(CompletionStage<? extends T> other,Consumer<? super T> action);

    //同上，异步执行
    public CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action);

    //同上，再指定的执行中异步执行
    public CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action,
         Executor executor);

    //当前阶段或入参中的other阶段二者之一正常完成时执action动作
    public CompletionStage<Void> runAfterEither(CompletionStage<?> other,Runnable action);

    //同上，异步执行
    public CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action);

    //同上，再指定的执行中异步执行
    public CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action,Executor executor);

    //当前阶段正常完成后其结果作为fn的入参同步执行fn并返回一个新的阶段，这里返回的新的阶段是由fn返回的,
    //注意区分thenCompose和thenApply，thenApply中的fn直接的返回的是阶段的执行结果，而thenCompose则直接返回的是一个阶段对象
    //其差别和Optional的flatMap和map的差别类似
    public <U> CompletionStage<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn);

    //同上，异步执行
    public <U> CompletionStage<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn);

    //同上，再执行器中异步执行
    public <U> CompletionStage<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn,Executor executor);

    //当前阶段发生异常时其异常结果作为入参同步执行fn并返回新的阶段
    public CompletionStage<T> exceptionally(Function<Throwable, ?