JUC_CompletableFuture异步编排

创建异步对象

公有线程池

public static ExecutorService executor=new ThreadPoolExecutor(5, 10, 100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(20));

有返回值supplyAsync

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
	return 1 + 1;
}, executor);
System.out.println(future.get());

无返回值runAsync

CompletableFuture.runAsync(()->{
    int i=1+1;
}, executor);

任务完成时回调方法

任务完成后感知结果和异常whenCompleteAsync、exceptionally

CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    return 1 + 1;
    // 感知到异常，无法修改结果
}, executor).whenCompleteAsync((result,exception)->{
    System.out.println(result+":"+exception);
    // 感知到异常，同时返回另外值（非结果相关值）
},executor).exceptionally(exception->{
   return 1+1;
});

任务完成后处理结果和异常handle

CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
    return 1 + 1;
}, executor).handle((result,exception)->{
    if(result!=null){
        return  result;
    }
    return -1;
});

线程串行化

不接收前一任务的结果，自身无返回值thenRunAsync

CompletableFuture<Void> future4 = CompletableFuture.supplyAsync(() -> {
    return 1 + 1;
}, executor).thenRunAsync(()->{
    System.out.println("silence");
}, executor);

接收前一任务的结果，自身无返回值thenAcceptAsync

CompletableFuture<Void> future5 = CompletableFuture.supplyAsync(() -> {
    return 1 + 1;
}, executor).thenAcceptAsync(System.out::println, executor);

接收前一任务的结果，自身有返回值thenApplyAsync

CompletableFuture<Object> future6 = CompletableFuture.supplyAsync(() -> {
    return 1 + 1;
}, executor).thenApplyAsync(result->{
    return result*2;
},executor);
System.out.println(future6.get());

两任务完成后，执行第三任务

CompletableFuture<Integer> future7 = CompletableFuture.supplyAsync(() -> {
    System.out.println(1);
    return 1 + 1;
}, executor);

CompletableFuture<Integer> future8 = CompletableFuture.supplyAsync(() -> {
    System.out.println(2);
    return 2 + 2;
}, executor);

//runAfterBoth不能获取前两者结果
future7.runAfterBothAsync(future8, ()->{
    System.out.println(3);
}, executor);
//thenAcceptBoth获取两者返回值，无返回值
future7.thenAcceptBothAsync(future8, (r1,r2)->{
    System.out.println(r1+r2);
},executor);
//thenCombine获取两者返回值,有返回值
CompletableFuture<Integer> future9 = future7.thenCombineAsync(future8, Integer::sum, executor);
System.out.println(future9.get());

两任务之一完成后，执行第三任务

//runAfterEither不感知结果，无返回值
future7.runAfterEitherAsync(future8, ()->{
    System.out.println("one completed");
}, executor);
//acceptEither 感知第一个完成的结果，无返回值
future7.acceptEitherAsync(future8, System.out::println, executor);
//applyToEither感知第一个完成的结果，有返回值
future7.applyToEitherAsync(future8, result->{
    return result*2;
}, executor);

多任务组合

CompletableFuture<Integer> future11 = CompletableFuture.supplyAsync(() -> {
    System.out.println(1);
    return 1 + 1;
}, executor);

CompletableFuture<Integer> future12 = CompletableFuture.supplyAsync(() -> {
    System.out.println(2);
    return 2 + 2;
}, executor);

CompletableFuture<Integer> future13 = CompletableFuture.supplyAsync(() -> {
    System.out.println(3);
    return 3 + 3;
}, executor);
// 等待所有任务都完成
CompletableFuture<Void> allOf = CompletableFuture.allOf(future11, future12, future13);
//无返回值
allOf.get();
System.out.println(future11.get()+":"+future12.get()+":"+future13.get());

//有一个任务完成，返回值为完成任务的返回值
CompletableFuture<Object> anyOf = CompletableFuture.anyOf(future11, future12, future13);
Object o = anyOf.get();