Java8 - CompletableFuture 异步编程类

其他异步编程方法

Java5中新增了Future接口,用来描述异步计算的结果。虽然 Future 以及相关使用方法提供了异步执行任务的能力,但是对于结果的获取却是很不方便,只能通过阻塞或者轮询的方式得到任务的结果。阻塞的方式显然和我们的异步编程的初衷相违背,轮询的方式又会耗费无谓的 CPU 资源,而且也不能及时地得到计算结果。

CompletableFuture的优点

  1. 支持事件回调(任务完成,任务异常等)由于它实现了Future接口,所以也可以用get()阻塞式的获取结果
  2. 支持串行执行、并行执行、合并异步结果、组合异步任务,即把上一个任务的输出作为下一个任务的输入
  3. 无需手工维护线程,语义清晰,代码优雅

使用方法

CompletableFuture的使用流程大致分为三步

  1. 创建CompletableFuture对象
  2. 描述任务关系(串行,并行,汇聚)
  3. 处理异步计算结果

创建

//比较特殊,入参就是返回值,返回值就是异步计算的结果
public static <U> CompletableFuture<U> completedFuture(U value)

//无返回值,使用默认线程池
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)

描述串行关系

  • 有Async的是异步方法
//接收上一任务的输出并输出结果
CompletionStage<R> thenApply(fn);
CompletionStage<R> thenApplyAsync(fn);
//接收上一任务的输出,但不输出结果
CompletionStage<Void> thenAccept(consumer);
CompletionStage<Void> thenAcceptAsync(consumer);
//不接收输入,也不输出结果
CompletionStage<Void> thenRun(action);
CompletionStage<Void> thenRunAsync(action);
//和thenApply类似,类似map和flatmap的区别
CompletionStage<R> thenCompose(fn);
CompletionStage<R> thenComposeAsync(fn);

示例

CompletableFuture.completedFuture("hello").thenApply(s -> {
 System.out.println("任务1:"+Thread.currentThread().getId());
 return s+" word";
}).thenApplyAsync(s->{
 System.out.println("任务2:"+Thread.currentThread().getId());
 return s+" !";
}).thenAccept(System.out::println);
System.out.println("主线程:"+Thread.currentThread().getId());
Thread.sleep(4000);
/*
输出结果
任务1:1
主线程:1
任务2:15
hello word !
*/

注意上面的代码,任务1是thenApply()同步方法,任务2是thenApplyAsync()异步方法。从输出结果可以看到,同步方法是在主线程执行的,而异步方法则丢到线程池执行。任务2虽然是异步方法,但由于是串行执行,它还是要等待任务1执行完毕才能执行。

描述AND汇聚关系

//有Async的是异步方法
//接收上一任务的输出,并输出结果
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);

示例

创建f1和f2两个异步任务,然后等待f1和f2都执行完毕,将结果相加后打印

CompletableFuture<String> f1=CompletableFuture.supplyAsync(()->"hello");
CompletableFuture<String> f2=CompletableFuture.supplyAsync(()->"world");
f1.thenCombine(f2,(s, s2) -> s+" "+s2).thenAccept(System.out::println);
//输出hello world

描述OR汇聚关系

//有Async的是异步方法
//接收上一任务的输出,并输出结果
CompletionStage applyToEither(other, fn);
CompletionStage applyToEitherAsync(other, fn);
//接收上一任务的输出,但不输出结果
CompletionStage acceptEither(other, consumer);
CompletionStage acceptEitherAsync(other, consumer);
//不接收上一任务的输出,也不输出结果
CompletionStage runAfterEither(other, action);
CompletionStage runAfterEitherAsync(other, action);

示例

创建两个异步任务,哪个任务先执行完就输出谁

CompletableFuture<String> f1 =
    CompletableFuture.supplyAsync(()->{
        int t = (int) (Math.random()*1000)+1000;
        try {
            Thread.sleep(t);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } 
        return String.valueOf(t);
    }).whenCompleteAsync((s, throwable) -> System.out.println(s));
CompletableFuture<String> f2 =
     CompletableFuture.supplyAsync(()->{
         int t = (int) (Math.random()*1000)+1000;
         try {
            Thread.sleep(t);
         } catch (InterruptedException e) {
            e.printStackTrace();
         } 
           return String.valueOf(t);
     }).whenCompleteAsync((s, throwable) -> System.out.println(s));
CompletableFuture<String> f3 = f1.applyToEither(f2,s -> s);
System.out.println(f3.join());
Thread.sleep(2000);

事件回调

//任务异常回调,有返回值,可以自己返回
CompletionStage<R> exceptionally(fn);
//任务完成回调,有返回值,但这个返回值是异步任务的结果,我们不能返回
CompletionStage<R> whenComplete(consumer);
CompletionStage<R> whenCompleteAsync(consumer);
//任务完成回调,有返回值,可以自己返回
CompletionStage<R> handle(fn);
CompletionStage<R> handleAsync(fn);

示例

CompletableFuture<Integer> f0 =
     CompletableFuture.supplyAsync(()->7/0).thenApply(r->r*10)
     //放在exceptionally前面,可以获取到异步任务的结果,放在放在exceptionally后面,只能获取到exceptionally返回的结果
     .whenComplete((integer, throwable) -> System.out.println(integer))
     .exceptionally(t->{
         t.printStackTrace();
         //会覆盖异步任务的结果
         return -1;
     });
System.out.println(f0.join());
Thread.sleep(2000);

其他方法

//接收多个CompletableFuture任务,等待全部任务执行完毕
public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)
//接收多个CompletableFuture任务,等待任意一个任务执行完毕,并返回执行结果
public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)

评论

暂无评论