CompletableFuture使用

一、CompletableFuture简介

https://my.oschina.net/u/2307176/blog/3196557 之前分析过FutureTask，FutureTask实现了Future接口，作为一个Task存在的，其本身是不管理线程池执行过程的，只是借助了Future的特性来来控制我们的任务，例如取消任务、设置超时时间获取任务执行结果。

CompletableFuture实现了Future和CompletionStage，表示异步计算的中不同阶段，可以对这些阶段进行组合。CompletableFuture会将任务委托给线程池处理，我们可以指定线程池Executor，也可以使用默认的ForkJoinPool，任务一般是Runnable、Supplier、Consumer、Function的实现。

二、使用ComletableFuture

我们根据功能分类，大概有三类方法：同步方法、带Async且指定Executor的异步方法，带Async使用默认ForkJoinPool的异步方法

1.创建ComletableFuture

// 构造方法
public CompletableFuture() {}

// 创建一个已经完成的CompletableFuture
public static <U> CompletableFuture<U> completedFuture(U value) {}

// 无返回值任务，使用默认的线程池
public static CompletableFuture<Void> runAsync(Runnable runnable){}

// 无返回值任务，使用指定的Executor
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor){}

// 有返回值任务，使用默认的线程池
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {}

// 有返回值任务，使用指定的Executor
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor) {}

// 任务组合
public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs) {}
public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs) {}

2.thenApply、thenApplyAsync

public <U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn) {}
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn) {}
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn, Executor executor) {}

可以连接多个CompletableFuture，将上一个CompletableFuture计算的结果当作入参进行计算，返回一个新的CompletableFuture，并且其计算结果由Function的apply()返回值决定。

3.thenAccept、thenAccpetAsync

public CompletableFuture<Void> thenAccept(Consumer<? super T> action) {}
public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action) {}
public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action, Executor executor){}

thenAccpet会消费上一个CompletableFuture的计算结果，返回一个新的CompletableFuture，并且该CompletatbleFuture是没有计算结果的，get方法返回NULL。

4.whenComplete、whenCompleteAsync

public CompletableFuture<T> whenComplete(}
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action){}
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action, Executor executor) {}

当上一个CompletableFuture执行完成后，不论是否成功执行出结果还是发生异常，whenComplete都会执行且会返回新的CompletableFuture，并且该CompletableFuture和上一个CompletableFuture的计算结果是同一个结果。

5.exceptionally

public CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn) {}

不论上一个CompletableFuture计算结果过程是否发生异常，exceptionally都会执行。若上一个CompletableFuture执行过程发生异常，那么exceptionally方法执行后返回的CompletableFuture的结果由自己决定。若上一个CompletableFuture执行没有异常，那么当前的CompletableFuture和上一个CompletableFuture的计算结果是同一个结果。(注意：若CompletableFuture在计算时抛出异常了，那么在调用get方法时会直接抛出异常)

6.handle、handleAsync

public <U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn) {}
public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn) {}
public <U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, Executor executor) {}

handle执行后会返回一个新的CompletableFuture，其对应的结果由handle方法决定，和上一个CompletableFuture的计算结果不是同一个结果。

7.thenAcceptBoth、thenAcceptBothAsync

public <U> CompletableFuture<Void> thenAcceptBoth(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action){}
public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action) {}
public <U> CompletableFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> other, BiConsumer<? super T, ? super U> action, Executor executor) {}

在两个CompletableFuture都执行完成之后再执行自己的计算，执行完之后会返回一个新的CompletableFuture，该CompletableFuture不返回任何计算结果，thenAccept只能消费一个CompletableFuture的计算结果；而thenAcceptBoth可以消费两个CompletableFuture的计算结果，并且是必须在两个CompletableFuture计算出结果之后才消费。

8.thenRun、thenRunAsync

public CompletableFuture<Void> thenRun(Runnable action) {}
public CompletableFuture<Void> thenRunAsync(Runnable action) {}
public CompletableFuture<Void> thenRunAsync(Runnable action, Executor executor) {}

在上一个CompletableFuture执行完之后，再执行，不返回结果，也不消费上一个CompletableFuture的结算结果。

9.acceptEither、accpetEitherAsync

public CompletableFuture<Void> acceptEither(CompletionStage<? extends T> other, Consumer<? super T> action);
public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action) {}
public CompletableFuture<Void> acceptEitherAsync(CompletionStage<? extends T> other, Consumer<? super T> action, Executor executor) {}

当两个CompletableFuture中，有任何一个计算完成，就会执行，不返回结算结果。

10.applyToEither、applyToEitherAsync

public <U> CompletableFuture<U> applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn) {}
public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn) {}
public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn, Executor executor) {}

当两个CompletableFuture中，有任何一个计算完成，就会执行，计算结果由Function的apply方法决定。

11.runAfterBoth、runAfterBothAsync、runAfterEither、runAfterEitherAsync

public CompletableFuture<Void> runAfterBoth(CompletionStage<?> other, Runnable action) {}
public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action) {}
public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other, Runnable action, Executor executor) {}

public <U> CompletableFuture<U> applyToEither(CompletionStage<? extends T> other, Function<? super T, U> fn) {}
public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn) {}
public <U> CompletableFuture<U> applyToEitherAsync(CompletionStage<? extends T> other, Function<? super T, U> fn, Executor executor) {}

runAfterBoth是当两个CompletableFuture都计算完之后，才执行计算。不消耗计算结果，也不返回计算结果。

runAfterEither是两个CompletableFuture中有一个计算完成，就执行计算，返回计算结果。

12.thenCombine、thenCombineAsync、thenCompose、thenComposeAsync

public <U,V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn) {}
public <U,V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn) {}
public <U,V> CompletableFuture<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn, Executor executor) {}

public <U> CompletableFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn) {}
public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn) {}
public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn, Executor executor) {}

thenCombine结合前面两个CompletableFuture的计算结果，进行本次计算，返回新的计算结果。

thenCompose连接两个CompletableFuture，组合成一个新的CompletableFuture，参考flatMap。

来源：oschina

链接：https://my.oschina.net/u/2307176/blog/3198244

标签

executor

completablefuture