核心内容摘要
Labelbox团队的AI智能代理新突破：理解用户真正需要什么
并行执行两个任务A和B。
主线程等待时间最长为3s。
所以A和B单独运行的时长最长也是3s。
且如果A和B都没有超时那么优先取A的值。
否者谁不超时就取谁。
线程池单个提交比如下面的代码先提交了两个异步任务此时都已经开始执行了。
主线程此时等待taskA任务结束。
任务A用时时间为a。
那么任务B此时也执行了a时间所以taskB剩余时间为3s - a。
publicstaticvoidmain(String[]args){long configTime3000;ExecutorServiceexecutorServiceExecutors.newFixedThreadPool(
;FutureStringtaskAexecutorService.submit(()-{try{Thread.sleep(newRandom().nextInt(
);}catch(InterruptedExceptione){e.printStackTrace();}returntaskA;});FutureStringtaskBexecutorService.submit(()-{try{Thread.sleep(newRandom().nextInt(
);}catch(InterruptedExceptione){e.printStackTrace();}returntaskB;});Stringresultnull;long timeStartSystem.currentTimeMillis();try{resulttaskA.get(configTime,TimeUnit.MILLISECONDS);}catch(InterruptedExceptione){thrownewRuntimeException(e);}catch(ExecutionExceptione){thrownewRuntimeException(e);}catch(TimeoutExceptione){thrownewRuntimeException(e);}long timeEndSystem.currentTimeMillis();try{resulttaskB.get(configTime-(timeEnd-timeStart),TimeUnit.MILLISECONDS);}catch(InterruptedExceptione){thrownewRuntimeException(e);}catch(ExecutionExceptione){thrownewRuntimeException(e);}catch(TimeoutExceptione){thrownewRuntimeException(e);}System.out.println(result);}invokeAllinvoekAll 同时执行一批任务设置整体的超时时间。
这批任务要么执行完成要么超时了未完成的任务将被取消。
所以每一个任务的状态都是done。
publicstaticvoidmain(String[]args)throwsExecutionException,InterruptedException{long configTime3000;ExecutorServiceexecutorServiceExecutors.newFixedThreadPool(
;CallableStringtaskA()-{int time0;try{timenewRandom().nextInt(
;Thread.sleep(time);// Thread.sleep(
;}catch(InterruptedExceptione){e.printStackTrace();}returntaskAtime;};CallableStringtaskB()-{int time0;try{timenewRandom().nextInt(
;Thread.sleep(time);// Thread.sleep(
;}catch(InterruptedExceptione){e.printStackTrace();}returntaskB time;};long startSystem.currentTimeMillis();ListFutureStringfuturesexecutorService.invokeAll(Arrays.asList(taskA,taskB),configTime,TimeUnit.MILLISECONDS);//
遍历获取结果FutureStringfutureAfutures.get(
;FutureStringfutureBfutures.get(
;long endSystem.currentTimeMillis();if(!futureA.isCancelled()){System.out.println(futureA.get());}else{System.out.println(任务A超时被取消);}if(!futureB.isCancelled()){System.out.println(futureB.get());}else{System.out.println(任务B超时被取消);}System.out.println(耗时(end-start));}CompletableFuturepublicstaticvoidmain(String[]args)throwsExecutionException,InterruptedException,TimeoutException{// 超时时间配置和原代码一致long configTime3000;// 保持和原代码一致的线程池配置避免使用默认ForkJoinPoolExecutorServiceexecutorServiceExecutors.newFixedThreadPool(
;// 定义任务A替换原CallableCompletableFutureStringfutureACompletableFuture.supplyAsync(()-{int timenewRandom().nextInt(
;try{Thread.sleep(time);}catch(InterruptedExceptione){e.printStackTrace();return任务A被中断;}returntaskAtime;},executorService)// 设置超时时间超时抛出TimeoutException.orTimeout(configTime,TimeUnit.MILLISECONDS)// 捕获超时/异常返回超时提示.exceptionally(ex-{if(ex instanceofTimeoutException){return任务A超时被取消;}else{return任务A执行异常ex.getMessage();}});// 定义任务B替换原CallableCompletableFutureStringfutureBCompletableFuture.supplyAsync(()-{int timenewRandom().nextInt(
;try{Thread.sleep(time);}catch(InterruptedExceptione){e.printStackTrace();return任务B被中断;}returntaskB time;},executorService)// 设置超时时间.orTimeout(configTime,TimeUnit.MILLISECONDS)// 捕获超时/异常.exceptionally(ex-{if(ex instanceofTimeoutException){return任务B超时被取消;}else{return任务B执行异常ex.getMessage();}});// 记录开始时间long startSystem.currentTimeMillis();// 等待所有任务完成无论成功/超时/异常CompletableFuture.allOf(futureA,futureB).join();// 记录结束时间long endSystem.currentTimeMillis();// 获取并输出结果System.out.println(futureA.join());System.out.println(futureB.join());System.out.println(耗时(end-start));}CompletableFuture 与传统线程池的核心区别解析你作为Java新手想搞清楚CompletableFuture和传统线程池如ThreadPoolExecutor/Executors创建的线程池的核心区别我会从定位、用法、核心能力三个维度用通俗的语言实战示例帮你理清——核心结论先抛给你传统线程池是“执行任务的线程容器”而CompletableFuture是“基于线程池的异步编程工具”前者解决“线程管理”问题后者解决“异步流程编排”问题。
核心定位与设计目标最根本的区别特性传统线程池ThreadPoolExecutorCompletableFuture核心定位线程的“管理者”创建、复用、销毁线程异步流程的“编排者”基于线程池实现异步编程设计目标解决线程创建/销毁的开销问题提高线程复用率解决传统Future的阻塞、无法链式调用、无法组合任务的痛点依赖关系独立的基础组件依赖线程池可使用默认/commonPool或自定义线程池简单说传统线程池只负责“找个线程执行你的任务”而CompletableFuture帮你“优雅地处理任务的异步结果、组合多个异步任务”。
核心能力对比附实战示例
结果获取方式阻塞 vs 异步回调最直观的区别传统线程池提交任务后只能通过Future.get()阻塞式获取结果或轮询isDone()主线程会被卡住而CompletableFuture支持非阻塞的异步回调任务完成后自动触发后续逻辑。
示例1传统线程池的痛点阻塞获取结果import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class TraditionalThreadPoolDemo { public static void main(String[] args) throws Exception { //
创建传统线程池 ExecutorService pool Executors.newFixedThreadPool(
; //
提交任务获取Future System.out.println(主线程提交任务开始等待结果...); FutureString future pool.submit(() - { Thread.sleep(
; // 模拟耗时操作 return 传统线程池的结果; }); //
必须阻塞等待结果get()主线程卡2秒 String result future.get(); // 阻塞主线程停在这里 System.out.println(主线程获取到结果 result); pool.shutdown(); } }执行结果主线程会卡在get()处2秒后才打印结果期间主线程无法做任何事。
示例2CompletableFuture的异步回调非阻塞import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class CompletableFutureDemo { public static void main(String[] args) throws InterruptedException { //
自定义线程池复用传统线程池 ExecutorService pool Executors.newFixedThreadPool(
; //
提交任务异步回调主线程不阻塞 System.out.println(主线程提交任务继续执行其他逻辑...); CompletableFuture.supplyAsync(() - { try { Thread.sleep(
; } catch (InterruptedException e) { throw new RuntimeException(e); } return CompletableFuture的结果; }, pool) // 指定自定义线程池执行 .thenAccept(result - { // 任务完成后自动执行异步回调不阻塞主线程 System.out.println(回调线程获取到结果 result); }); //
主线程不阻塞立即执行这行代码 System.out.println(主线程我在做其他事比如打印日志、处理请求...); // 等待回调执行完仅示例用实际业务无需手动等 Thread.sleep(
; pool.shutdown(); } }执行结果主线程提交任务继续执行其他逻辑... 主线程我在做其他事比如打印日志、处理请求... 2秒后 回调线程获取到结果CompletableFuture的结果
任务组合能力无 vs 强大传统线程池无法直接组合多个任务比如“等3个任务都完成后汇
总结果”需要手动写逻辑判断代码繁琐而CompletableFuture内置allOf/anyOf等方法轻松实现多任务组合。
示例多任务组合传统线程池 vs CompletableFuture传统线程池需要手动创建多个Future循环判断是否全部完成代码量大且易出错CompletableFuture一行allOf()就能等待所有任务完成代码简洁。
// CompletableFuture组合多任务传统线程池做不到这么优雅 CompletableFutureString task1 CompletableFuture.supplyAsync(() - 任务
; CompletableFutureString task2 CompletableFuture.supplyAsync(() - 任务
; // 等待所有任务完成 CompletableFutureVoid allTasks CompletableFuture.allOf(task1, task
; allTasks.thenRun(() - { System.out.println(所有任务完成汇
总结果 task
join() , task
join()); });
异常处理繁琐 vs 优雅传统线程池任务异常只能在get()时抛出ExecutionException必须手动try-catch且只能在获取结果时处理CompletableFuture内置exceptionally()/handle()方法能在异步流程中直接处理异常不用等到获取结果时才处理。
// CompletableFuture优雅处理异常 CompletableFuture.supplyAsync(() - { throw new RuntimeException(任务执行失败); }).exceptionally(ex - { // 异常时返回兜底值 System.out.println(捕获异常 ex.getMessage()); return 兜底结果; }).thenAccept(result - System.out.println(最终结果 result)); // 输出“兜底结果”
总结核心区别定位不同传统线程池是“线程管理工具”负责执行任务CompletableFuture是“异步编程工具”基于线程池实现异步流程编排回调、组合、异常处理。
结果处理不同传统线程池只能阻塞获取结果CompletableFuture支持非阻塞的异步回调主线程不被卡。
能力边界不同传统线程池无任务组合、优雅异常处理能力CompletableFuture内置这些能力是对传统线程池Future的增强。
新手小贴士实际开发中不会用CompletableFuture替代传统线程池而是结合使用——用自定义线程池管理线程避免默认池耗尽用CompletableFuture编排异步任务回调、组合。
Java CompletableFuture 快速入门从基础到组合你作为Java新手想要快速掌握CompletableFuture的核心用法我会用最易懂的方式结合实战代码帮你“速成”——重点聚焦日常开发中最常用的核心功能避开复杂的底层原理让你能马上上手。
先搞懂CompletableFuture是什么CompletableFuture是Java 8新增的异步编程工具解决了传统Future只能阻塞获取结果、无法链式调用的痛点。
简单说它能异步执行任务不阻塞主线程支持链式回调任务执行完自动触发后续逻辑能组合多个异步任务比如“同时执行多个任务全部完成后汇
总结果”自带异常处理机制不用手动try-catch。
核心用法速成重点附可运行代码前置说明所有示例基于Java 8无需额外依赖默认使用JDK的ForkJoinPool.commonPool()线程池也可自定义线程池文末会提。
基础创建异步任务分两种核心场景无返回值、有返回值。
import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; public class CompletableFutureQuickStart { public static void main(String[] args) throws ExecutionException, InterruptedException { // 场景1无返回值的异步任务runAsync CompletableFutureVoid future1 CompletableFuture.runAsync(() - { // 异步执行的逻辑比如耗时操作读写文件、调用接口 try { Thread.sleep(
; // 模拟耗时1秒 } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println(任务1执行完成无返回值); }); // 阻塞等待任务完成新手调试用实际开发尽量用回调避免阻塞 future
get(); // 场景2有返回值的异步任务supplyAsync CompletableFutureString future2 CompletableFuture.supplyAsync(() - { try { Thread.sleep(
; } catch (InterruptedException e) { throw new RuntimeException(e); } System.out.println(任务2执行完成有返回值); return 任务2的返回结果; // 返回任意类型String/对象/基本类型 }); // 获取返回值阻塞式 String result2 future
get(); System.out.println(任务2返回值 result
; } }关键解释runAsync(Runnable)适合执行“只做事、不返回结果”的异步任务返回CompletableFutureVoidsupplyAsync(SupplierT)适合执行“需要返回结果”的异步任务返回CompletableFutureTT是返回值类型get()阻塞当前线程直到任务完成并获取结果新手慎用实际优先用回调。
核心异步回调避免阻塞不用get()阻塞而是让任务执行完自动触发后续逻辑这是CompletableFuture的
核心价值。
方法作用输入输出示例场景thenApply接收上一步结果返回新值有输入有输出对异步结果做加工处理thenApplyAsync接收上一步结果返回新值有输入有输出与thenApply不同点重启另外一个线程执行applyToEither接收上一步结果返回新值有输入有输出二者取快的那一个和anyOf类似thenAccept接收上一步结果无返回值有输入无输出消费结果比如打印、入库thenAcceptAsync接收上一步结果无返回值有输入无输出与thenAccept不同点重启另外一个线程执行acceptEither接收上一步结果无返回值有输入无输出二者取快的那一个和anyOf类似thenRun不接收结果无返回值无输入无输出结果处理完后执行收尾操作public class CompletableFutureCallback { public static void main(String[] args) throws InterruptedException { //
thenApply加工结果有输入有输出 CompletableFutureInteger futureApply CompletableFuture.supplyAsync(() -
.thenApply(num - num *
// 接收10返回20 .thenApply(num - num
; // 接收20返回25 futureApply.thenAccept(result - System.out.println(thenApply最终结果 result)); // 输出25 //
thenAccept消费结果有输入无输出 CompletableFuture.supplyAsync(() - Hello) .thenAccept(str - System.out.println(thenAccept消费 str World)); // 输出Hello World //
thenRun无输入无输出 CompletableFuture.runAsync(() - System.out.println(任务执行中...)) .thenRun(() - System.out.println(thenRun任务执行完做收尾)); // 任务结束后执行 // 等待所有回调执行完仅示例用实际不用手动等 Thread.sleep(
; } }
必学异常处理异步任务抛异常时用exceptionally或handle处理避免程序崩溃。
public class CompletableFutureException { public static void main(String[] args) throws ExecutionException, InterruptedException { // 场景1exceptionally仅处理异常正常结果透传 CompletableFutureInteger future1 CompletableFuture.supplyAsync(() - { if (true) { throw new RuntimeException(任务执行失败); } return 100; }).exceptionally(ex - { // 异常时返回默认值 System.out.println(捕获异常 ex.getMessage()); return 0; // 兜底值 }); System.out.println(exceptionally结果 future
get()); // 输出0 // 场景2handle同时处理正常结果和异常 CompletableFutureInteger future2 CompletableFuture.supplyAsync(() -
.handle((result, ex) - { if (ex ! null) { System.out.println(handle捕获异常 ex.getMessage()); return -1; } return result * 2; // 正常时加工结果 }); System.out.println(handle结果 future
get()); // 输出400 } }
常用任务组合实际开发中常需要“并行执行多个任务汇
总结果”核心用allOf全部完成、anyOf任意一个完成。
public class CompletableFutureCombine { public static void main(String[] args) throws ExecutionException, InterruptedException { //
allOf等待所有任务完成无返回值需手动获取每个任务结果 CompletableFutureString task1 CompletableFuture.supplyAsync(() - 任务1结果); CompletableFutureString task2 CompletableFuture.supplyAsync(() - 任务2结果); CompletableFutureString task3 CompletableFuture.supplyAsync(() - 任务3结果); CompletableFutureVoid allFuture CompletableFuture.allOf(task1, task2, task
; allFuture.get(); // 等待所有任务完成 // 获取每个任务的结果 String result1 task
get(); String result2 task
get(); String result3 task
get(); System.out.println(allOf汇
总结果 result1 , result2 , result
; //
anyOf任意一个任务完成就返回返回第一个完成的结果 CompletableFutureString fastTask CompletableFuture.supplyAsync(() - { try { Thread.sleep(
; // 最快完成 } catch (InterruptedException e) { throw new RuntimeException(e); } return 快任务结果; }); CompletableFutureString slowTask CompletableFuture.supplyAsync(() - { try { Thread.sleep(
; } catch (InterruptedException e) { throw new RuntimeException(e); } return 慢任务结果; }); CompletableFutureObject anyFuture CompletableFuture.anyOf(fastTask, slowTask); Object anyResult anyFuture.get(); System.out.println(anyOf结果 anyResult); // 输出“快任务结果” } }
进阶自定义线程池避免共用线程池耗尽默认的commonPool是所有异步任务共用的高并发下可能耗尽建议自定义线程池import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class CompletableFutureCustomPool { // 自定义线程池核心数CPU核心数新手先这么配 private static final ExecutorService CUSTOM_POOL Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()); public static void main(String[] args) { // 创建任务时指定自定义线程池 CompletableFuture.supplyAsync(() - { System.out.println(自定义线程池执行 Thread.currentThread().getName()); return 自定义线程池结果; }, CUSTOM_POOL) .thenAccept(System.out::println); // 程序结束前关闭线程池实际项目中线程池通常是单例不用手动关 CUSTOM_POOL.shutdown(); } }
三、
总结作为Java新手掌握以下3个核心点就能应对80%的CompletableFuture使用场景创建任务runAsync无返回值、supplyAsync有返回值优先用自定义线程池回调处理thenApply加工结果、thenAccept消费结果替代get()避免阻塞异常与组合用exceptionally兜底异常用allOf/anyOf组合多任务。
不用死记所有API先把上面的示例跑通、理解遇到具体场景再查对应方法即可——这就是最适合新手的“速成”方式。