在高并发系统中,异步编程是提升性能的关键。本文聚焦 Future 和 CompletableFuture 的核心用法,通过真实代码示例和高频面试题解析,助你掌握异步编程精髓。 
一、Future 的局限性(为什么需要 CompletableFuture)
// Future基本用法
Callable<Integer> task = () -> {
Thread.sleep(1000);
return 100;
};
FutureTask<Integer> futureTask = new FutureTask<>(task);
new Thread(futureTask).start();
System.out.println(futureTask.get()); // 阻塞等待结果
Future 的致命缺陷:
面试题高亮解析:
Q:为什么 Future 不能满足复杂异步场景?
A:Future 是"阻塞式"的,无法实现"任务完成后自动执行下个任务"的链式操作。例如,要实现"查询商品信息 → 生成订单 → 发送通知"的链式操作,Future 需要手动等待每个任务完成,代码冗长且难以维护。
二、CompletableFuture 实战(核心方法与代码示例)
1. 创建异步操作
// 无返回结果的异步任务
CompletableFuture.runAsync(() -> {
System.out.println("执行无返回结果的异步任务");
});
// 有返回结果的异步任务
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Hello World";
});
// 获取结果(join() vs get())
String result = future.join(); // 无检查异常
// String result = future.get(); // 需要处理Checked异常
关键点:join()抛出 unchecked 异常,get()需要处理 checked 异常。
2. 结果处理与转换(核心!)
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
// 1. 结果转换(thenApply)
CompletableFuture<String> result1 = future.thenApply(s -> s + " World");
System.out.println(result1.join()); // "Hello World"
// 2. 结果组合(thenCombine)
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);
CompletableFuture<Integer> result2 = future1.thenCombine(future2, (a, b) -> a + b);
System.out.println(result2.join()); // 30
// 3. 任务交互(applyToEither)
CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
try { Thread.sleep(1000); } catch (InterruptedException e) {}
return 5;
});
CompletableFuture<Integer> future4 = CompletableFuture.supplyAsync(() -> {
try { Thread.sleep(500); } catch (InterruptedException e) {}
return 10;
});
CompletableFuture<Integer> result3 = future3.applyToEither(future4, x -> x * 2);
System.out.println(result3.join()); // 20(最快完成的5*2=10?不,是10*2=20)
面试题高亮解析:
Q:thenApply 和 thenCompose 的区别是什么?
A:
- thenApply:转换结果类型,返回新 CompletableFuture(CompletableFuture<String> result = future.thenApply(s -> s + " World");)
- thenCompose:展开内部 CompletableFuture,返回新 CompletableFuture(CompletableFuture<String> result = future.thenCompose(s -> CompletableFuture.supplyAsync(() -> s + " World"));)关键:thenApply 是"单层转换",thenCompose 是"多层任务组合"。
三、CompletableFuture 高级用法(面试必考)
1. 异常处理
CompletableFuture.supplyAsync(() -> {
if (new Random().nextInt(10) % 2 == 0) {
throw new RuntimeException("测试异常");
}
return "正常结果";
}).exceptionally(e -> {
System.out.println("发生异常: " + e.getMessage());
return "异常处理结果";
}).join(); // "异常处理结果"
面试题高亮解析:
Q:CompletableFuture 的异常处理机制是什么?
A:
- exceptionally(Function<Throwable, T> fn):捕获异常并返回默认值
- whenComplete(BiConsumer<T, Throwable> action):处理正常结果或异常(不改变结果)区别:exceptionally 会返回新 CompletableFuture,whenComplete 只是执行动作,不改变结果。
2. 任务组合(allOf & anyOf)
// allOf:等待所有任务完成
CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> "任务1");
CompletableFuture<String> f2 = CompletableFuture.supplyAsync(() -> "任务2");
CompletableFuture<Void> all = CompletableFuture.allOf(f1, f2);
all.join(); // 等待所有任务完成
// anyOf:等待任意一个任务完成
CompletableFuture<String> f3 = CompletableFuture.supplyAsync(() -> {
try { Thread.sleep(1000); } catch (InterruptedException e) {}
return "任务3";
});
CompletableFuture<String> f4 = CompletableFuture.supplyAsync(() -> {
try { Thread.sleep(500); } catch (InterruptedException e) {}
return "任务4";
});
CompletableFuture<Object> any = CompletableFuture.anyOf(f3, f4);
System.out.println(any.join()); // 优先返回"任务4"(更快完成的)
面试题高亮解析:
Q:allOf 和 anyOf 的区别是什么?
A:
- allOf:等待所有任务完成(类似"&&"逻辑)
- anyOf:等待任意一个任务完成(类似"||"逻辑)应用场景:
- allOf:需要所有数据都准备好的场景(如订单生成需要商品、库存、用户信息)
- anyOf:只要有一个数据源可用的场景(如查询多个数据源,优先使用最快的)
四、实战案例:实现最优的"烧水泡茶"程序
// 基于Future的实现(线程间依赖,代码冗长)
public class FutureTaskDemo3 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask<String> ft2 = new FutureTask<>(new T2Task());
FutureTask<String> ft1 = new FutureTask<>(new T1Task(ft2));
new Thread(ft1).start();
new Thread(ft2).start();
System.out.println(ft1.get()); // "上茶:龙井"
}
}
// T1Task需要等待T2Task完成
class T1Task implements Callable<String> {
FutureTask<String> ft2;
T1Task(FutureTask<String> ft2) { this.ft2 = ft2; }
@Override
public String call() throws Exception {
System.out.println("T1:洗水壶…");
Thread.sleep(1000);
System.out.println("T1:烧开水…");
Thread.sleep(15000);
String tf = ft2.get(); // 阻塞等待T2完成
System.out.println("T1:拿到茶叶:" + tf);
System.out.println("T1:泡茶…");
return "上茶:" + tf;
}
}
// T2Task独立执行
class T2Task implements Callable<String> {
@Override
public String call() throws Exception {
System.out.println("T2:洗茶壶…");
Thread.sleep(1000);
System.out.println("T2:洗茶杯…");
Thread.sleep(2000);
System.out.println("T2:拿茶叶…");
Thread.sleep(1000);
return "龙井";
}
}
// 基于CompletableFuture的实现(简洁高效)
public class CompletableFutureDemo2 {
public static void main(String[] args) {
// 任务1:洗水壶->烧开水
CompletableFuture<Void> f1 = CompletableFuture.runAsync(() -> {
System.out.println("T1:洗水壶…");
sleep(1, TimeUnit.SECONDS);
System.out.println("T1:烧开水…");
sleep(15, TimeUnit.SECONDS);
});
// 任务2:洗茶壶->洗茶杯->拿茶叶
CompletableFuture<String> f2 = CompletableFuture.supplyAsync(() -> {
System.out.println("T2:洗茶壶…");
sleep(1, TimeUnit.SECONDS);
System.out.println("T2:洗茶杯…");
sleep(2, TimeUnit.SECONDS);
System.out.println("T2:拿茶叶…");
sleep(1, TimeUnit.SECONDS);
return "龙井";
});
// 任务3:任务1和任务2完成后执行:泡茶
CompletableFuture<String> f3 = f1.thenCombine(f2, (__, tf) -> {
System.out.println("T1:拿到茶叶:" + tf);
System.out.println("T1:泡茶…");
return "上茶:" + tf;
});
System.out.println(f3.join()); // "上茶:龙井"
}
static void sleep(int t, TimeUnit u) {
try { u.sleep(t); } catch (InterruptedException e) {}
}
}
面试题高亮解析:
Q:CompletableFuture 相比 Future 在"烧水泡茶"案例中有什么优势?
A:
关键提示:在阿里、腾讯等大厂面试中,CompletableFuture 是并发编程的必考题。务必掌握:



