Java CompletableFuture 异步并发
1. CompletableFuture 异步编程
1.1 使用工厂方法supplyAsync创建CompletableFuture
CompletableFuture<String> aFuture = CompletableFuture.supplyAsync(()->doSomeThingA());
CompletableFuture<String> bFuture = CompletableFuture.supplyAsync(()->doSomeThingB());
try {
String aResult = aFuture.get(2, TimeUnit.SECONDS);
String bResult = bFuture.get();
System.out.println(aResult+ ", " + bResult);
} catch (Exception e) {
throw new RuntimeException(e);
}
- get 方法
定义Future的异步返回,通过supplyAsync一行代码实现异步操作,会将任务提交给ForkJoinPool的线程池进行操作。其中get可以设置超时,避免一直等待,如果超时了会抛出java.util.concurrent.TimeoutException异常。
- join 方法
join方法和get方法使用类似,阻塞获取值,区别在于 join() 抛出的是 unchecked Exception。
- runAsync 方法
runAsync 方法接收的是 Runnable 的实例,意味着它没有返回值
- supplyAsync 方法
upplyAsync 方法对应的是有返回值的情况, 方法的带 executor 的变种,表示让任务在指定的线程池中执行,不指定的话,通常任务是在 ForkJoinPool.commonPool() 线程池中执行的。
1.2 实施串行关系
先执行A,再执行B。
CompletionStage<R> thenApply(fn);
CompletionStage<R> thenApplyAsync(fn);
CompletionStage<Void> thenAccept(consumer);
CompletionStage<Void> thenAcceptAsync(consumer);
CompletionStage<Void> thenRun(action);
CompletionStage<Void> thenRunAsync(action);
CompletionStage<R> thenCompose(fn);
CompletionStage<R> thenComposeAsync(fn);
参考例子如下:
CompletableFuture<String> strFuture = CompletableFuture.supplyAsync(() -> "ABC").thenApply(s -> s+ "D").thenApply(String::toLowerCase);
System.out.println(strFuture.join());
1.2 多任务组合执行
- AND 组合关系
CompletionStage<R> thenCombine(other, fn);
CompletionStage<R> thenCombineAsync(other, fn);
CompletionStage<Void> thenAcceptBoth(other, consumer);
CompletionStage<Void> thenAcceptBothAsync(other, consumer);
CompletionStage<Void> runAfterBoth(other, action);
CompletionStage<Void> runAfterBothAsync(other, action);
具体实施例子如下:
CompletableFuture<String> aFuture = CompletableFuture.supplyAsync(()->doSomeThingA());
CompletableFuture<String> bFuture = CompletableFuture.supplyAsync(()->doSomeThingB());
try {
aFuture.thenAcceptBoth(bFuture, (aResult, bResult)->{
System.out.println(aResult+ ", " + bResult);
});
/*
CompletableFuture<String> cResult = aFuture.thenCombine(bFuture, (aResult, bResult)->{
return aResult + "," + bResult;
});
System.out.println(cResult.get());
*/
} catch (Exception e) {
throw new RuntimeException(e);
}
- OR组合关系
CompletionStage applyToEither(other, fn);
CompletionStage applyToEitherAsync(other, fn);
CompletionStage acceptEither(other, consumer);
CompletionStage acceptEitherAsync(other, consumer);
CompletionStage runAfterEither(other, action);
CompletionStage runAfterEitherAsync(other, action);
具体实施例子如下:
cfA.acceptEither(cfB, result -> {});
cfA.acceptEitherAsync(cfB, result -> {});
cfA.acceptEitherAsync(cfB, result -> {}, executorService);
cfA.applyToEither(cfB, result -> {return result;});
cfA.applyToEitherAsync(cfB, result -> {return result;});
cfA.applyToEitherAsync(cfB, result -> {return result;}, executorService);
cfA.runAfterEither(cfA, () -> {});
cfA.runAfterEitherAsync(cfB, () -> {});
cfA.runAfterEitherAsync(cfB, () -> {}, executorService);
- allOf 和 anyOf
public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)
public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)
实现例子1 : 异步调用,等全部结果返回,统一处理。
public static int i = 0;
static CompletableFuture<String> doTask(String taskId) {
return CompletableFuture.supplyAsync(() -> {
// mock task
try {
System.out.println(Thread.currentThread().getName() + ":start!");
Thread.sleep((++i) * 1000);
System.out.println(Thread.currentThread().getName() + ":end!");
} catch (InterruptedException e) {
e.printStackTrace();
}
return "task" + taskId;
});
}
public static void batchProcess(List<String> taskIdList) {
// 并行task
List<CompletableFuture<String>> taskFutureList = taskIdList.stream().map(taskId -> doTask(taskId)).collect(Collectors.toList());
// 使用allOf标识所有的并行任务
CompletableFuture<Void> allFuture = CompletableFuture.allOf(taskFutureList.toArray(new CompletableFuture[taskFutureList.size()]));
// 获取所有子任务的处理结果
CompletableFuture<List<String>> finalResults = allFuture.thenApply(v -> taskFutureList.stream()
.map(taskFuture -> taskFuture.join()).collect(Collectors.toList()));
try {
List<String> l = finalResults.get();
System.out.println(l);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
实现例子2:
public static int i = 0;
static <T> T doTask(T taskId) {
// mock task
try {
System.out.println(Thread.currentThread().getName() + ":start!");
Thread.sleep((++i) * 1000);
System.out.println(Thread.currentThread().getName() + ":end!");
} catch (InterruptedException e) {
e.printStackTrace();
}
return taskId;
}
public static <T> List<T> batchProcess(List<T> taskList, ExecutorService executor) {
List<CompletableFuture<T>> futures = new ArrayList<>();
for (int i = 0; i < taskList.size(); i++) {
final int j = i;
//异步执行
CompletableFuture<T> future = CompletableFuture.supplyAsync(() -> doTask(taskList.get(j)), executor)
//如需获取任务完成先后顺序,此处代码即可
.whenComplete((v, e) -> {
System.out.println("任务" + v + "完成!result=" + v + ",异常 e=" + e + "," + new Date());
});
futures.add(future);
}
//1.构造一个空CompletableFuture,子任务数为入参任务list size
CompletableFuture<Void> allDoneFuture = CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()]));
try {
//2.流式(总任务完成后,每个子任务join取结果,后转换为list)
return allDoneFuture.thenApply(v -> futures.stream().map(CompletableFuture::join).collect(Collectors.toList())).get();
}catch (Exception e) {
e.printStackTrace();
}
return null;
}
// main函数调用
ExecutorService executor = Executors.newFixedThreadPool(10);
List<String> taskList = new ArrayList<>();
taskList.add("A");
taskList.add("B");
List<String> result = batchProcess(taskList, executor);
result.forEach(k -> {
System.out.println(k);
});
1.3 异常处理
- whenComplete(…)
功能:当CompletableFuture的计算结果完成,或者抛出异常的时候,都可以进入whenComplete方法执行
public CompletionStage<T> whenComplete(BiConsumer<? super T, ? super Throwable> action);
public CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action);
public CompletionStage<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action,Executor executor);
实现的例子如下:
CompletableFuture<String> future = CompletableFuture.supplyAsync(()-> "执行结果:" + (100 / 0))
.thenApply(s -> "apply result:" + s)
.whenComplete((s, e) -> {
if (s != null) {
System.out.println(s); // 未执行
}
if (e == null) {
System.out.println(s); // 未执行
} else {
System.out.println(e.getMessage());//java.lang.ArithmeticException: / by zero
}
}).exceptionally(e -> {
System.out.println("ex: "+e.getMessage()); //ex:java.lang.ArithmeticException: / by zero
return "futureA result: 100";
});
System.out.println(future.join());
- handle(…)
功能:当CompletableFuture的计算结果完成,或者抛出异常的时候,可以通过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<String> futureA = CompletableFuture.
supplyAsync(() -> "执行结果:" + (100 / 0))
.thenApply(s -> "apply result:" + s)
.handle((s, e) -> {
if (e == null) {
System.out.println(s);//未执行
} else {
System.out.println(e.getMessage());//java.lang.ArithmeticException: / by zero
}
return "handle result:" + (s == null ? "500" : s);
})
.exceptionally(e -> {
System.out.println("ex:" + e.getMessage()); //未执行
return "futureA result: 100";
});
System.out.println(futureA.join());//handle result:500