CompletableFuture整理及拓展

最新推荐文章于 2025-06-17 18:36:31 发布

liuhstop1

最新推荐文章于 2025-06-17 18:36:31 发布

阅读量193

点赞数

CC 4.0 BY-SA版权

文章标签： java 后端

本文链接：https://blog.youkuaiyun.com/liuhstop1/article/details/132588307

思维导图

CompletableFuture使用及api介绍

一.创建CompletableFuture对象

//异步执行一个有返回值的任务
CompletableFuture demoFuture1 = CompletableFuture.supplyAsync(()->{ return "ss";});
//异步执行一个无返回值的任务
CompletableFuture demoFuture2 = CompletableFuture.runAsync(()->{System.out.println("ss");});
//创建一个已经完成的CompletableFuture对象
CompletableFuture demoFuture3 = CompletableFuture.completedFuture("ss");
// 创建一个未完成的CompletableFuture对象
CompletableFuture  demoFuture4 = new CompletableFuture();

二.组合CompletableFuture对象

//在CompletableFuture对象上执行一个函数，并返回一个新的带返回值的CompletableFuture对象
CompletableFuture<String> demoFuture1 = CompletableFuture.supplyAsync(()-> "ss");
CompletableFuture demoFuture2 = demoFuture1.thenApply((String s)->{    return s+"t";});

//在CompletableFuture对象上执行一个消费者，并返回一个新的CompletableFuture对象
CompletableFuture demoFuture3 = demoFuture1.thenAccept((String s)->{   System.out.println(s);});

//在CompletableFuture对象上执行一个Runnable，并返回一个新的CompletableFuture对象
CompletableFuture demoFuture4 = demoFuture1.thenRun(()->{    System.out.println("ss");});

//在CompletableFuture对象上执行一个函数，返回一个新的CompletableFuture对象 和thenApply很像，但是需要自己手动返回CompletableFuture对象
CompletableFuture<String> demoFuture5 = demoFuture1.thenCompose((String s)->{       
       System.out.println(s); 
       return new CompletableFuture();
});
//将两个CompletableFuture对象的结果组合起来，并执行一个函数，返回一个新的
CompletableFuture对象demoFuture1.thenCombine(demoFuture5,(t,s)->{    return s+t;});

//allOf(CompletableFuture... cfs)：等待所有的CompletableFuture对象执行完成
CompletableFuture  allofCompletableFuture = CompletableFuture.allOf(demoFuture1,demoFuture2);

//anyOf(CompletableFuture... cfs)：等待任意一个CompletableFuture对象执行完成
CompletableFuture  anyofCompletableFuture = CompletableFuture.anyOf(demoFuture1,demoFuture2);

//acceptEither(CompletionStage other, Consumer action)：两个CompletableFuture对象任意一个完成后执行指定的消费者
CompletableFuture acceptEitherFuture = demoFuture1.acceptEither(demoFuture2,(s)->{    System.out.println(s);});

//applyToEither(CompletionStage other, Function fn)：两个CompletableFuture对象任意一个完成后执行指定的函数，并返回一个新的CompletableFuture对象
CompletableFuture applyToEitherFuture =  demoFuture1.applyToEither(demoFuture2,(s)->{    return s;});

//runAfterBoth(CompletionStage other, Runnable action)：两个CompletableFuture对象都完成后执行指定的Runnable
CompletableFuture runAfterBothFuture =  demoFuture1.runAfterBoth(demoFuture2,()->{    System.out.println("ss");});

//runAfterEither(CompletionStage other, Runnable action)：两个CompletableFuture对象任意一个完成后执行指定的Runnable
CompletableFuture runAfterEitherFuture =  demoFuture1.runAfterEither(demoFuture2,()->{    System.out.println("ss");});

//thenAcceptBoth(CompletionStage other, BiConsumer action)：将两个CompletableFuture对象的结果组合起来，并执行一个消费者
CompletableFuture thenAcceptBothFuture = demoFuture1.thenAcceptBoth(demoFuture2,(s,t)->{    System.out.println(s);    System.out.println(t);});

三.处理CompletableFuture对象的结果

//get()：获取CompletableFuture对象的结果，如果任务还未完成，则会阻塞等待
CompletableFuture<String> demoFuture1 = CompletableFuture.supplyAsync(()-> "ss");
try {    
  demoFuture1.get();
} catch (InterruptedException e) 
{    
  e.printStackTrace();
} catch (ExecutionException e) {    
  e.printStackTrace();
}
//get(long timeout, TimeUnit unit)：获取CompletableFuture对象的结果，如果任务还未完成，则会阻塞等待一段时间
try {    
   demoFuture1.get(1000, TimeUnit.MILLISECONDS);
   } catch (InterruptedException e) {    
     e.printStackTrace();
   } catch (ExecutionException e) {   
    e.printStackTrace();
   } catch (TimeoutException e) {    
    e.printStackTrace();
   }
//join()：获取CompletableFuture对象的结果，如果任务还未完成，则会一直阻塞，和get的区别在于不抛出异常，get方法需要手动捕获
demoFuture1.join();
//cancel(boolean mayInterruptIfRunning)：尝试取消CompletableFuture对象的执行
demoFuture1.cancel(true);
//isCancelled()：判断CompletableFuture对象是否被取消
demoFuture1.isCancelled();
//isCompletedExceptionally()：判断CompletableFuture对象是否执行异常
demoFuture1.isCompletedExceptionally();
//isDone()：判断CompletableFuture对象是否执行完成
demoFuture1.isDone();

四.结果异常处理

//exceptionally(Function fn)：处理CompletableFuture对象执行过程中的异常
CompletableFuture<String> demoFuture1 = CompletableFuture.supplyAsync(()-> "ss");

demoFuture1.exceptionally((Throwable e)->{    
 System.out.println(e.getMessage());    
 return "s";
});

//handle(BiFunction fn)：处理CompletableFuture对象执行过程中的异常，同时处理正常结果
demoFuture1.handle((t,e)->{    
 System.out.println(t.toUpperCase());   
 System.out.println(e.getMessage());    
 return "s";
});

五.指定业务线程池

private static final Executor executor = TtlExecutors.getTtlExecutor(new ThreadPoolExecutor(1,1,3000, TimeUnit.MILLISECONDS,new ArrayBlockingQueue(100)));
//使用指定的线程池执行异步任务,不指定的话默认走ForkJoinPool线程池
//默认ForkJoinPool线程池，ForkJoinPool里面的线程都是daemon线程，非daemon线程都结束后，虚拟机也就退出了。
//如果需要执行较长时间或执行内容比较重要不希望被中断而导致数据不一致的话，那就自己传一个Executor吧

CompletableFuture<String> demoFuture1 = CompletableFuture.supplyAsync(()-> "ss",executor);
CompletableFuture demoFuture2 = CompletableFuture.runAsync(()->{    System.out.println("s");},executor);