欢迎光临
我们一直在努力

异步编程Future&CompletableFuture实战

在高并发系统中,异步编程是提升性能的关键。本文聚焦 Future 和 CompletableFuture 的核心用法,通过真实代码示例和​高频面试题解析​,助你掌握异步编程精髓。 image.png


一、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 的致命缺陷:

  • ​只能阻塞等待​:get() 方法会阻塞主线程,无法实现非阻塞异步
  • ​无法链式调用​:无法在任务完成后自动触发后续操作
  • ​无法组合多个任务​:无法并行执行多个任务并等待全部完成
  • ​异常处理缺失​:没有统一的异常处理机制
  • 面试题高亮解析:

    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​:

  • ​代码简洁​:无需手动管理 FutureTask 和线程依赖
  • ​异步协作​:通过 thenCombine 实现任务间自动协作,无需阻塞等待
  • ​可读性强​:直观表达"任务 1 和任务 2 完成后执行任务 3"的业务逻辑
  • ​无阻塞等待​:thenCombine 自动处理任务依赖,无需手动调用 get()

  • 关键提示:在阿里、腾讯等大厂面试中,CompletableFuture 是并发编程的必考题。务必掌握:

  • thenApply/thenCompose 的区别(面试官最爱问)
  • exceptionally 与 whenComplete 的使用场景
  • allOf 与 anyOf 的业务场景
  • 任务依赖的优雅实现(如"烧水泡茶"案例)
  • 赞(0)
    未经允许不得转载:171主机测评 » 异步编程Future&CompletableFuture实战
    分享到: 更多 (0)

    评论 抢沙发

    • 昵称 (必填)
    • 邮箱 (必填)
    • 网址