CompletableFuture 和 CompletionStage JDK1.8新特性异步执行任务控制

• 1、CompletableFuture 和 CompletionStage

Future 获取结果需要堵塞get()或轮询isDone() ,未实现异步执行完后采用通知或回调的方法，
JDK8中提供了CompletableFuture与CompletionStage,是对于Future的补充
CompletionStage：执行某一个阶段，可向下执行后续阶段
异步执行，没有提供Executor，默认线程是ForkJoinPool.commonPool()中。

• 1.1、CompletableFuture 提交任务执行，获取结果

CompletableFuture.runAsync(Runnable runnable) 执行没有返回值任务。
CompletableFuture.supplyAsync(Supplier<U> supplier) 执行有返回值任务

CompletableFuture.allOf(CompletableFuture<?>... cfs)
当所有给定的CompletableFutures完成后，完成
CompletableFuture.anyOf(CompletableFuture<?>... cfs)
当任何一个CompletableFuture完成则完成

• 1.2、获取执行结果

allOf和anyOf 要想获取返回值必须用get()或者join()方法获取返回值，否则都是异步执行。

• 2、CompletableFuture 异步执行结果再次处理，返回的都是CompletionStage 阶段
• 2.1、执行下一阶段

CompletableFuture.thenApply(Function<? super T,? extends U> fn) 此阶段执行完成，此阶段结果作为下一阶段的参数出入；下一阶段有返回值
CompletableFuture.thenApplyAsync(Function<? super T,? extends U> fn) 同thenApply，只是执行线程和上一阶段执行线程不是同一个

CompletableFuture.thenAccept(Consumer<? super T> action) 此阶段执行完成，此阶段结果作为下一阶段的参数出入；下一阶段没有返回值
CompletableFuture.thenAcceptAsync(Consumer<? super T> action) 同thenAccept，只是执行线程和上一阶段执行线程不是同一个

• 2.2、任务串行执行，一个任务接着一个执行

CompletableFuture.thenRun(Runnable action) 执行完上一阶段后执行，不处理返回值
CompletableFuture.thenRunAsync(Runnable action) 同thenRun，新线程执行

public class CompletableFutureTest {
    public static void main(String[] args) {
        CompletableFuture.runAsync(()->{
            log("步骤1");
        }).thenRun(()->{
            log("步骤2");
        });

        CompletableFuture.supplyAsync(() -> {
            log("第一阶段有返回值");
            return "1";
        }).thenAccept(result->{
            log(result);
        });

    }
    private static void log(String msg){
        System.out.println(Thread.currentThread().getName()+"-msg = " + msg);
    }
}

• 2.3、2个任务进行合并有返回值

CompletableFuture.thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)
当这个和另一个给定的阶段都正常完成时，两个结果作为提供函数的参数执行
CompletableFuture.thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn)
同thenCombine，新线程执行
 

public void test4(){
        CompletableFuture<Integer> integerCompletableFuture =
                CompletableFuture.supplyAsync(() -> 6)
                .thenCombine(CompletableFuture.supplyAsync(() -> 4), (one, two) -> one + two);
        System.out.println(integerCompletableFuture.join());
    }

• 2.4 任务合并无返回值    

CompletableFuture.thenAcceptBoth(CompletionStage<? extends U> other, BiConsumer<? super T,? super U> action)

public void test4(){
            CompletableFuture.supplyAsync(() -> 1)
                    .thenAcceptBoth(CompletableFuture.supplyAsync(() -> 2), (one, two) -> System.out.println(one + two));
    }

 

• 2.5、当这个阶段和另一个阶段都正常完成时，调用指定的操作    

CompletableFuture.runAfterBoth(CompletionStage<?> other, Runnable action)

public class CompletableFutureTest {
    public static void main(String[] args) {
        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.supplyAsync(() -> {
            log("第一个阶段执行");
            return 6;
        })
                .runAfterBoth(CompletableFuture.runAsync(() -> {
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    log("第2个阶段");
                }), () -> {
                    log("前面2个阶段都执行完成后");
                });
        voidCompletableFuture.join();

    }
    private static void log(String msg){
        System.out.println(Thread.currentThread().getName()+"-msg = " + msg);
    }
}

• 2.6、当这个阶段或给定的阶段有一个正常完成时，调用指定的操作

CompletableFuture.runAfterEither(CompletionStage<?> other, Runnable action)

• 2.7、执行完这个阶段后，以结果和执行结果的异常作为参数执行后续操作

CompletableFuture.whenComplete(BiConsumer<? super T,? super Throwable> action)
CompletableFuture.supplyAsync(() -> 8).whenComplete((r,throwable)->System.out.println(r));

• 2.8、当这个阶段正常完成时，这个阶段将作为提供函数的参数执行

CompletableFuture.thenCompose(Function<? super T,? extends CompletionStage<U>> fn)
CompletableFuture.supplyAsync(() -> 5).thenCompose(i-> CompletableFuture.supplyAsync(()->i));

• 2.9、当此阶段正常或异常完成时，将使用此阶段的结果和异常作为所提供函数的参数执行

CompletableFuture.handle(BiFunction<? super T,Throwable,? extends U> fn)
CompletableFuture.supplyAsync(() -> 3).handle((r,throwable)-> r+2);

• 2.10、获取执行结果 如get(),join()

CompletableFuture.complete(T value)