CompletableFuture类总结
```java
public class CompletableFuture<T> implements Future<T>, CompletionStage<T> {
// 1、创建一个异步操作:无返回值
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);
// 2、计算结果完成时的回调方法:异步线程执行完毕就执行
public CompletableFuture<T> whenComplete(BiConsumer<? super T,? super Throwable> action)
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action)
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action, Executor executor)
// 只有发生了异常才执行
public CompletableFuture<T> exceptionally(Function<Throwable,? extends T> fn);
// 3、当一个线程依赖另一个线程时,可以使用 thenApply 方法来把这两个线程串行化。
// T:上一个任务返回结果的类型
// U:当前任务的返回值类型
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)
// 4、执行任务完成时对结果的处理。
// handle 方法和 thenApply 方法处理方式基本一样。不同的是 handle 是在任务完成后再执行,还可以处理异常的任务。thenApply 只可以执行正常的任务,任务出现异常则不执行 thenApply 方法。
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);
// 5、接收任务的处理结果,并消费处理,无返回结果。
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);
// 6、跟 thenAccept 方法不一样的是,不关心任务的处理结果。只要上面的任务执行完成,就开始执行 thenAccept 。
public CompletionStage<Void> thenRun(Runnable action);
public CompletionStage<Void> thenRunAsync(Runnable action);
public CompletionStage<Void> thenRunAsync(Runnable action,Executor executor);
// 7、合并任务
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);
// 8、当两个CompletionStage都执行完成后,把结果一块交给thenAcceptBoth来进行消费
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);
// 9、两个CompletionStage,谁执行返回的结果快,我就用那个CompletionStage的结果进行下一步的转化操作。
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);
// 10、两个CompletionStage,谁执行返回的结果快,我就用那个CompletionStage的结果进行下一步的消耗操作。
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);
// 11、两个CompletionStage,任何一个完成了都会执行下一步的操作(Runnable)
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);
// 12、两个CompletionStage,都完成了计算才会执行下一步的操作(Runnable)
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);
// 13、thenCompose 方法允许你对两个 CompletionStage 进行流水线操作,第一个操作完成时,将其结果作为参数传递给第二个操作。
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);
// 14、allOf 可以把多个任务都完成之后执行
public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs);
// 15、anyOf多个任务中有一个任务完成就执行:只有其中的一个值
public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs);
}
示例
```java
package com.qiqitrue.java.juc;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
/**
* @description:
* @author: laiqi
* @created: 2020-09-24 19:57
*/
public class CompletableFutureExample {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// handle();
// then();
// runAfterBothAsync();
// runAfterEitherAsync();
allOf();
}
/**
* 1、创建异步对象:无返回值的线程
*/
public static void runAsync() {
System.out.println("主线程开始");
CompletableFuture.runAsync(() -> {
System.out.println("线程开始..");
int a = 10 / 2;
System.out.println("线程结束..");
});
System.out.println("主线程退出");
}
/**
* 1、创建异步对象:有返回值的线程
*
* @throws ExecutionException
* @throws InterruptedException
*/
public static void supplyAsync() throws ExecutionException, InterruptedException {
System.out.println("主线程开始");
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
System.out.println("线程开始..");
int a = 10 / 2;
System.out.println("线程结束..");
return a;
});
Integer integer = completableFuture.get();
System.out.println("主线程退出");
}
/**
* 完成时回调执行:
* 1、whenComplete:异步线程执行完毕就执行
* 2、exceptionally:只有发生了异常才执行
*
* @throws ExecutionException
* @throws InterruptedException
*/
public static void whenComplete() throws ExecutionException, InterruptedException {
System.out.println("主线程开始");
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
System.out.println("线程开始..");
int a = 10 / 2;
System.out.println("线程结束..");
return a;
}).whenComplete((integer, throwable) -> {
System.out.println("我是whenComplete()方法:异步线程执行完毕之后就轮到我执行了,我可以获取返回值及异常信息,不能修改返回结果");
}).exceptionally(throwable -> {
System.out.println("我是exceptionally()方法:我只有在发生异常才会执行并返回出错时提供默认结果");
return 0;
});
Integer integer = completableFuture.get();
System.out.println("线程执行完毕返回值:" + integer);
System.out.println("主线程退出");
}
/**
* 完成时回调执行:
* handle:
* 当有异常时:whenComplete-->exceptionally-->handle
* 当无异常时:whenComplete-->handle
*
* @throws ExecutionException
* @throws InterruptedException
*/
public static void handle() throws ExecutionException, InterruptedException {
System.out.println("主线程开始");
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
System.out.println("线程开始..");
int a = 10 / 2;
System.out.println("线程结束..");
return a;
}).whenComplete((integer, throwable) -> {
System.out.println("我是whenComplete()方法:异步线程执行完毕之后就轮到我执行了,我可以获取返回值及异常信息,不能修改返回结果");
}).exceptionally(throwable -> {
System.out.println("我是exceptionally()方法:我只有在发生异常才会执行并返回出错时提供默认结果");
return 0;
}).handle((integer, throwable) -> {
System.out.println("我是handle()方法:我可以获取返回值及异常信息,并且可以修改返回结果");
return 1;
});
Integer integer = completableFuture.get();
System.out.println("线程执行完毕返回值:" + integer);
System.out.println("主线程退出");
}
/**
* 线程串行化
* thenRunAsync:不可以接收前面的,自己不能有返回值
* thenAcceptAsync:可以接收前面的返回值,自己不能有返回值
* thenApplyAsync:可以接收前面的返回值,自己也需要返回值
*
* @throws ExecutionException
* @throws InterruptedException
*/
public static void then() throws ExecutionException, InterruptedException {
String result = CompletableFuture.supplyAsync(() -> {
System.out.println("线程A执行完毕");
return "A";
}).thenRunAsync(() -> {
System.out.println("线程B执行完毕,我是没有返回值的");
}).thenAcceptAsync(unused -> {
System.out.println("线程C执行完毕,获取上个线程执行的返回值 = " + unused);
}).thenApplyAsync(unused -> {
System.out.println("线程D执行完毕,获取上个线程执行的返回值 = " + unused);
return "D";
}).thenApplyAsync(unused -> {
System.out.println("线程E执行完毕,获取上个线程执行的返回值 = " + unused);
return "E";
}).get();
System.out.println("result = " + result);
}
/**
* 两任务组合-都要完成
*
* @throws ExecutionException
* @throws InterruptedException
*/
public static void runAfterBothAsync() throws ExecutionException, InterruptedException {
// 异步任务一:返回1
CompletableFuture<Integer> supplyAsync1 = CompletableFuture.supplyAsync(() -> {
System.out.println("异步任务一");
return 1;
});
// 异步任务二:返回2
CompletableFuture<Integer> supplyAsync2 = CompletableFuture.supplyAsync(() -> {
System.out.println("异步任务二");
return 2;
});
// // runAfterBothAsync:表示需要两个任务都执行完,才触发任务;但是不能接收前面任务的返回值,自己也不需要返回值
// supplyAsync1.runAfterBothAsync(supplyAsync2, () -> {
// System.out.println("runAfterBothAsync:需要异步任务一、异步任务二都执行之后我才执行;但是不能接收前面任务的返回值,自己也不需要返回值");
// });
// runAfterBothAsync:表示需要两个任务都执行完,才触发任务;可以接收前面任务的返回值,自己也不需要返回值
// supplyAsync1.thenAcceptBothAsync(supplyAsync2, (integer, integer2) -> {
// System.out.println("thenAcceptBothAsync:需要异步任务一、异步任务二都执行之后我才执行;可以接收前面任务的返回值,【任务一:"+integer+",任务二:"+integer2+"】,自己也不需要返回值");
// });
// thenCombineAsync:表示需要两个任务都执行完,才触发任务;可以接收前面任务的返回值,自己也需要返回值
supplyAsync1.thenCombineAsync(supplyAsync2, (integer, integer2) -> {
System.out.println("thenAcceptBothAsync:需要异步任务一、异步任务二都执行之后我才执行;可以接收前面任务的返回值,【任务一:" + integer + ",任务二:" + integer2 + "】,自己也不需要返回值");
return integer + integer2;
});
}
/**
* 两任务组合-两个任务中有一个任务完成就执行
*
* @throws ExecutionException
* @throws InterruptedException
*/
public static void runAfterEitherAsync() throws ExecutionException, InterruptedException {
// 异步任务一:返回1
CompletableFuture<Integer> supplyAsync1 = CompletableFuture.supplyAsync(() -> {
System.out.println("异步任务一");
return 1;
});
// 异步任务二:返回2
CompletableFuture<Integer> supplyAsync2 = CompletableFuture.supplyAsync(() -> {
try {
// 为了效果明显起见,增加下任务二慢点执行
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("异步任务二");
return 2;
});
// // runAfterEitherAsync:表示两个任务其一执行完就触发任务;但是不能接收前面任务的返回值,自己也不需要返回值
// supplyAsync1.runAfterEitherAsync(supplyAsync2, () -> {
// System.out.println("runAfterEitherAsync:需要异步任务一、异步任务二其中一个我就可以执行;但是不能接收前面任务的返回值,自己也不需要返回值");
// });
// // acceptEitherAsync:表示两个任务其一执行完就触发任务;可以接收前面任务的返回值,自己也需要返回值
// supplyAsync1.acceptEitherAsync(supplyAsync2, integer -> {
// System.out.println("acceptEitherAsync:需要异步任务一、异步任务二其中一个我就可以执行;可以接收前面任务的返回值,自己也不需要返回值,前面值:" + integer);
// });
// applyToEitherAsync:表示两个任务其一执行完就触发任务;可以接收前面任务的返回值,自己也需要返回值
supplyAsync1.applyToEitherAsync(supplyAsync2, integer -> {
System.out.println("applyToEitherAsync:需要异步任务一、异步任务二其中一个我就可以执行;可以接收前面任务的返回值,自己也需要返回值,前面值:" + integer);
return 1 + integer;
});
}
/**
* 多个任务全部都执行完
* allOf:全部都执行
* anyOf: 执行完任一个就行
*
* @throws ExecutionException
* @throws InterruptedException
*/
public static void allOf() throws ExecutionException, InterruptedException {
CompletableFuture<String> supplyAsyncA = CompletableFuture.supplyAsync(() -> {
System.out.println("异步任务一");
return "A";
});
CompletableFuture<String> supplyAsyncB = CompletableFuture.supplyAsync(() -> {
System.out.println("异步任务二");
return "B";
});
CompletableFuture<String> supplyAsyncC = CompletableFuture.supplyAsync(() -> {
System.out.println("异步任务三");
return "C";
});
// // allOf可以把多个任务都完成之后执行
// final CompletableFuture<Void> allOf = CompletableFuture.allOf(supplyAsyncA, supplyAsyncB, supplyAsyncC);
// // 阻塞等待
// allOf.get();
// System.out.println("异步任务一结果:" + supplyAsyncA.get());
// System.out.println("异步任务二结果:" + supplyAsyncB.get());
// System.out.println("异步任务三结果:" + supplyAsyncC.get());
// anyOf多个任务中有一个任务完成就执行:只有其中的一个值
final CompletableFuture<Object> anyOf = CompletableFuture.anyOf(supplyAsyncA, supplyAsyncB, supplyAsyncC);
// 阻塞等待
final Object rsult = anyOf.get();
System.out.println("获取:" + rsult);
}
}