启动异步任务
CompletableFuture提供了四个静态方法来创建一个异步操作。
public static CompletableFuture<Void> runAsync(Runnable runnable)
public static CompletableFuture<Void> runAsync(Runnable runnable,Executor executor)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,Executor executor)
1.runXxx都是没有返回结果的，supplyXxx都是可以获取返回结果的
2.可以传入自定义线程池，否则使用默认线程池
public static ExecutorService service = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
//CompletableFuture.runAsync(new Runable01(),service);
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 1, service);
Integer integer = future.get();
System.out.println(integer);
service.shutdown();
}
计算完成时回调方法
public CompletableFuture<T> whenComplete(
BiConsumer<? super T, ? super Throwable> action) {
return uniWhenCompleteStage(null, action);
}
public CompletableFuture<T> whenCompleteAsync(
BiConsumer<? super T, ? super Throwable> action) {
return uniWhenCompleteStage(asyncPool, action);
}
public CompletableFuture<T> whenCompleteAsync(
BiConsumer<? super T, ? super Throwable> action, Executor executor) {
return uniWhenCompleteStage(screenExecutor(executor), action);
}
public CompletableFuture<T> exceptionally(
Function<Throwable, ? extends T> fn) {
return uniExceptionallyStage(fn);
}
whenComplete可以处理和异常的计算结果，exceptionally处理异常情况
whenComplete和whenCompleteAsync区别：
- whenComplete：是执行当前任务的线程执行完毕后继续执行whenComplete的任务
- whenCompleteAsync：提交给线程池来执行
public static ExecutorService service = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
CompletableFuture<Integer> future =
CompletableFuture.supplyAsync(() ->{
int i=1/0;
return 1;
} , service)
//可以得到异常信息，但是没办法修改返回数据
.whenComplete((res,e)->System.out.println(res+":"+e))
//可以感知异常,同时可以修改返回数据
.exceptionally(e-> 10);
System.out.println(future.get());
service.shutdown();
}
handle方法
handle方法可以对结果进行处理（也可以处理异常），也可以改变返回值
public <U> CompletionStage<U> handle
(BiFunction<? super T, Throwable, ? extends U> fn);
public <U> CompletionStage<U> handleAsync
(BiFunction<? super T, Throwable, ? extends U> fn);
public <U> CompletionStage<U> handleAsync
(BiFunction<? super T, Throwable, ? extends U> fn,
Executor executor);
CompletableFuture<Integer> future =
CompletableFuture.supplyAsync(() ->{
int i=1/0;
return 1;
} , service).handleAsync((r,e)->e==null?100:200,service);
System.out.println(future.get());
线程串行化方法
public <U> CompletionStage<U> thenApplyAsync
(Function<? super T,? extends U> fn,
Executor executor);
public <U> CompletionStage<U> thenApplyAsync
(Function<? super T,? extends U> fn);
public <U> CompletionStage<U> thenApplyAsync
(Function<? super T,? extends U> fn,
Executor executor);
public CompletionStage<Void> thenAccept(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action,Executor executor);
public CompletionStage<Void> thenRun(Runnable action);
public CompletionStage<Void> thenRunAsync(Runnable action);
public CompletionStage<Void> thenRunAsync(Runnable action,Executor executor);
thenApply:当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前任务的返回值
thenAccept:消费处理结果，接受任务处理结果，并消费处理，无返回结果。
thenRun:只要上面的任务执行完成，就开始执行thenRun。不获取上一个任务的结果，业务返回结果。
带有Async都是异步执行的。以上都要前置任务成功完成。
//thenRunAsync测试
CompletableFuture future =
CompletableFuture.supplyAsync(() ->1, service)
.thenRunAsync(()-> System.out.println("执行完成"),service);
//thenApplyAsync测试
CompletableFuture future =
CompletableFuture.supplyAsync(() ->1, service)
.thenApplyAsync((i)-> {
System.out.println("执行完成");
return i;
},service);
System.out.println(future.get());
//thenAcceptAsync测试
CompletableFuture future =
CompletableFuture.supplyAsync(() ->1, service)
.thenAcceptAsync((i)-> {
System.out.println("执行完成"+":"+i);
},service);
System.out.println(future.get());
俩任务组合（都要完成）
public <U,V> CompletionStage<V> thenCombine
(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);
public <U,V> CompletionStage<V> thenCombineAsync
(CompletionStage<? extends U> other,
BiFunction<? super T,? super U,? extends V> fn,
Executor executor);
public <U> CompletionStage<Void> thenAcceptBoth
(CompletionStage<? extends U> other,
BiConsumer<? super T, ? super U> action);
public <U> CompletionStage<Void> thenAcceptBothAsync
(CompletionStage<? extends U> other,
BiConsumer<? super T, ? super U> action);
public <U> CompletionStage<Void> thenAcceptBothAsync
(CompletionStage<? extends U> other,
BiConsumer<? super T, ? super U> action,
Executor executor);
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);
两个任务必须都完成，才触发该任务。
thenCombine：组合两个future，获取两个future的返回值，并返回当前任务返回值。
thenAcceptBoth：组合两个future，获取两个future的返回值，处理任务，没有返回值。
runAfterBoth：组合两个future，不获取future结果，等待两个future完成后，执行当前任务，无返回值。
//测试thenCombine
CompletableFuture<Integer> future1 =
CompletableFuture.supplyAsync(() ->1, service);
CompletableFuture<Integer> future2 =
CompletableFuture.supplyAsync(() ->2, service);
CompletableFuture<Integer> future = future1.thenCombineAsync(future2, (t, u) -> t + u, service);
System.out.println(future.get());
//测试thenAcceptBoth
CompletableFuture<Integer> future1 =
CompletableFuture.supplyAsync(() ->1, service);
CompletableFuture<Integer> future2 =
CompletableFuture.supplyAsync(() ->2, service);
CompletableFuture<Void> future = future1.thenAcceptBothAsync(future2, (t, u) -> System.out.println(t+u), service);
System.out.println(future.get());
//测试runAfterBoth
CompletableFuture<Integer> future1 =
CompletableFuture.supplyAsync(() ->1, service);
CompletableFuture<Integer> future2 =
CompletableFuture.supplyAsync(() ->2, service);
CompletableFuture<Void> future = future1.runAfterBothAsync(future2, ()-> System.out.println("f1和f2执行完毕"), service);
System.out.println(future.get());
俩任务组合（一个完成）
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);
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);
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);
与前面讲的两个任务都要完成用法差不多，这里只需要两个中的一个任务完成即可。
//测试applyToEitherAsync
CompletableFuture<Integer> future1 =
CompletableFuture.supplyAsync(() ->1, service);
CompletableFuture<Integer> future2 =
CompletableFuture.supplyAsync(() ->2, service);
CompletableFuture<Integer> future = future1.applyToEitherAsync(future2, Function.identity(), service);
System.out.println(future.get());
多任务组合
public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs) {
return andTree(cfs, 0, cfs.length - 1);
}
public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs) {
return orTree(cfs, 0, cfs.length - 1);
}
allOf：等待所有任务完成
anyOf：只要有一个任务完成