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) ; public static <U> CompletableFuture<U> completedFuture (U value) ;
在这四个方法中，run开头的代表创建一个没有返回值的异步任务，supply开头的方法代表创建一个具备返回值的异步任务。同时这两类方法都支持指定执行线程池，如果不指定执行线程池，CompletableFuture则会默认使用ForkJoinPool.commonPool()线程池内的线程执行创建出的异步任务
案例：
public class CompletableFutureDemo {
public static void main(String[] args) throws Exception {
CompletableFuture cf =
CompletableFuture.supplyAsync(CompletableFutureDemo::evenNumbersSum)
// 链式编程：基于上个任务的返回继续执行新的任务
.thenApply(r -> {
System.out.println("获取上个任务的执行结果：" + r);
// 通过上个任务的执行结果完成计算：求和100所有数
return r + oddNumbersSum();
}).thenApplyAsync(r -> {
System.out.println("获取上个任务的执行结果：" + r);
Integer i = r / 0; // 拋出异常
return r;
}).handle((param, throwable) -> {
if (throwable == null) {
return param * 2;
}
// 获取捕获的异常
System.out.println(throwable.getMessage());
System.out.println("我可以在上个任务" +
"抛出异常时依旧执行....");
return -1;
}).thenCompose(x ->
CompletableFuture.supplyAsync(() -> x+1
)).thenRun(() -> {
System.out.println("我是串行无返回任务....");
});
// 主线程执行休眠一段时间
// 因为如果不为CompletableFuture指定线程池执行任务的情况下，
// CompletableFuture默认是使用ForkJoinPool.commonPool()的线程
// 同时是作为main线程的守护线程进行的，如果main挂了，执行异步任
// 务的线程也会随之终止结束，并不会继续执行异步任务
Thread.sleep(2000);
}
// 求和100内的偶数
private static int evenNumbersSum() {
int sum = 0;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) sum += i;
}
return sum;
}
// 求和100内的奇数
private static int oddNumbersSum() {
int sum = 0;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 1; i <= 100; i++) {
if (i % 2 != 0) sum += i;
}
return sum;
}
}
2.下一个任务依赖于上一个任务的执行结果时
// 可以基于CompletableFuture对象接着创建一个有返回任务
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)
// 可以在上一个任务执行失败的情况下接着执行
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对象接着创建一个无返回任务
CompletionStage<Void> thenRun(Runnable action);
CompletionStage<Void> thenRunAsync(Runnable action);
CompletionStage<Void> thenRunAsync(Runnable action,Executor executor);
// 与thenApply方法类似，但是thenApply方法操作的是同一个CompletableFuture
// 而该类方法则是生产新的CompletableFuture<返回值>对象进行操作
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)
- ①thenApply类：此类方法可以基于上一个任务再创建一个新的有返回型任务。
- ②handle类：与thenApply类作用相同，不同点在于thenApply类方法只能在上一个任务执行正常的情况下才能执行，当上一个任务执行抛出异常后则不会执行。而handle类在上个任务出现异常的情况下也可以接着执行。
- ③thenRun类：此类方法可以基于上一个任务再创建一个新的无返回型任务。
- ④thenCompose类：与thenApply类大致相同，不同点在于每次向下传递都是新的CompletableFuture对象，而thenApply向下传递的都是同一个CompletableFuture对象对象
案例：
public class CompletableFutureDemo {
public static void main(String[] args) throws Exception {
CompletableFuture cf =
CompletableFuture.supplyAsync(CompletableFutureDemo::evenNumbersSum)
// 链式编程：基于上个任务的返回继续执行新的任务
.thenApply(r -> {
System.out.println("获取上个任务的执行结果：" + r);
// 通过上个任务的执行结果完成计算：求和100所有数
return r + oddNumbersSum();
}).thenApplyAsync(r -> {
System.out.println("获取上个任务的执行结果：" + r);
Integer i = r / 0; // 拋出异常
return r;
}).handle((param, throwable) -> {
if (throwable == null) {
return param * 2;
}
// 获取捕获的异常
System.out.println(throwable.getMessage());
System.out.println("我可以在上个任务" +
"抛出异常时依旧执行....");
return -1;
}).thenCompose(x ->
CompletableFuture.supplyAsync(() -> x+1
)).thenRun(() -> {
System.out.println("我是串行无返回任务....");
});
// 主线程执行休眠一段时间
// 因为如果不为CompletableFuture指定线程池执行任务的情况下，
// CompletableFuture默认是使用ForkJoinPool.commonPool()的线程
// 同时是作为main线程的守护线程进行的，如果main挂了，执行异步任
// 务的线程也会随之终止结束，并不会继续执行异步任务
Thread.sleep(2000);
}
// 求和100内的偶数
private static int evenNumbersSum() {
int sum = 0;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) sum += i;
}
return sum;
}
// 求和100内的奇数
private static int oddNumbersSum() {
int sum = 0;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 1; i <= 100; i++) {
if (i % 2 != 0) sum += i;
}
return sum;
}
}
3.其他操作
// 阻塞主线程获取执行结果（与FutureTask.get()一致）
public T get();
// 上个方法的超时版本
public T get(long timeout,TimeUnit unit);
// 尝试获取执行结果，执行完成返回执行结果，未完成返回任务参数
public T getNow(T valueIfAbsent);
// 阻塞主线程等待任务执行结束
public T join();
// 无返回的异步任务正常执行完成后可以通过此方法写出返回值
public boolean complete(T value);
// 无返回的异步任务执行异常后可以通过此方法写出捕获的异常信息
public boolean completeExceptionally(Throwable ex);
// 任务正常执行完成后的回调函数：默认由执行任务的线程执行回调逻辑
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 CompletableFuture<T> exceptionally(Function<Throwable,? extends T> fn)
// 执行结束后会执行的回调逻辑
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)
①主线程调用直接获取执行结果的get、getNow方法
②可以为无返回值的异步任务写出执行结果的：complete开头的方法
②任务正常执行成功的回调：thenAccept开头的方法
④任务执行抛出异常的回调：exceptionally方法
⑤任务执行结束的回调：whenComplete开头的方法
4.任务之间的汇聚功能
AND类型：
- thenCombine系列：可以接收前面任务的结果进行汇聚计算，并且计算后可以返回值
- thenAcceptBoth系列：可以接收前面任务的结果进行汇聚计算，但计算后没有返回值
- runAfterBoth系列：不可以接收前面任务的结果且无返回，但可以在任务结束后进行汇聚计算
- CompletableFuture类的allOf系列：不可接收之前任务的结果，但可以汇聚多个任务，但是要配合回调处理方法一起使用
OR类型：
- applyToEither系列：接收最先完成的任务结果进行处理，处理完成后可以返回值
- acceptEither系列：接收最先完成的任务结果进行处理，但是处理完成后不能返回
- runAfterEither系列：不能接收前面任务的返回值且无返回，单可以为最先完成的任务进行后继处理
- CompletableFuture类的anyOf系列：可以同时汇聚任意个任务，并接收最先执行完成的任务结果进行处理，处理完成后没有返回值，需要配合回调方法一起使用
public class CompletableFutureDemo {
public static void main(String[] args) throws Exception {
/*--------------------创建两个异步任务CF1/CF2------------------*/
CompletableFuture<Integer> cf1 =
CompletableFuture.supplyAsync(CompletableFutureDemo::evenNumbersSum);
CompletableFuture<Integer> cf2 =
CompletableFuture.supplyAsync(CompletableFutureDemo::oddNumbersSum);
/*--------------------测试AND类型汇聚方法------------------*/
CompletableFuture<Integer> cfThenCombine = cf1.thenCombine(cf2, (r1, r2) -> {
System.out.println("cf1任务计算结果：" + r1);
System.out.println("cf2任务计算结果：" + r2);
return r1 + r2;
});
System.out.println("cf1,cf2任务ThenCombine汇聚处理结果：" + cfThenCombine.get());
// thenAcceptBoth、runAfterBoth系列与thenCombine差不多相同
// 区别就在于入参BiFunction、BiConsumer、Runnable三个函数式接口的不同
// 使用allOf汇聚两个任务（可以汇聚多个）
CompletableFuture cfAllOf = CompletableFuture.allOf(cf1, cf2);
// 配合thenAccept成功回调函数使用
cfAllOf.thenAccept( o -> System.out.println("所有任务完成后进行断后处理...."));
//分割线
Thread.sleep(2000);
System.err.println("--------------------------------------");
/*--------------------测试OR类型汇聚方法------------------*/
CompletableFuture<Integer> cfApplyToEither = cf1.applyToEither(cf2, r -> {
System.out.println("最先执行完成的任务结果：" + r);
return r * 10;
});
System.out.println("cf1,cf2任务applyToEither汇聚处理结果："+cfApplyToEither.get());
// acceptEither、runAfterEither系列与applyToEither系列也差不多相同
// 区别就也是在于入参BiFunction、BiConsumer、Runnable三个函数式接口的不同
// 使用anyOf汇聚两个任务，谁先执行完成就处理谁的执行结果
CompletableFuture cfAnyOf = CompletableFuture.anyOf(cf1, cf2);
// 配合thenAccept成功回调函数使用
cfAnyOf.thenAccept(r -> {
System.out.println("最先执行完成的任务结果：" + r);
System.out.println("对先完成的任务结果进行后续处理....");
});
}
// 求和100内的偶数
private static int evenNumbersSum() {
int sum = 0;
try {
Thread.sleep(800); // 模拟耗时
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) sum += i;
}
return sum;
}
// 求和100内的奇数
private static int oddNumbersSum() {
int sum = 0;
try {
Thread.sleep(1000); // 模拟耗时
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 1; i <= 100; i++) {
if (i % 2 != 0) sum += i;
}
return sum;
}
}
