CompletableFuture：让你的代码免受阻塞之苦

最新推荐文章于 2025-11-30 21:13:21 发布

原创

最新推荐文章于 2025-11-30 21:13:21 发布 · 1.8k 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#线程 #Future #异步处理

本文详细介绍了Java中的CompletableFuture，它用于简化异步编程，提高接口性能。通过实例展示了如何创建和使用CompletableFuture，包括同步和异步方法，异常处理，结果获取以及组合多个异步任务。文章还对比了CompletableFuture与Future的区别，并讨论了其在IO密集型任务中的应用场景。最后，提到了优化CompletableFuture性能的注意事项，如自定义线程池以适应业务需求。

业务复杂一个接口查询多个数据源、通知多方系统导致接口性能是指提升不上去，tomcat线程池日常告急，CPU的利用率却不到百分之50，那肯定不能让他闲着，必须要增加线程让它忙起来，将一个接口的复杂逻辑拆分成多个异步任务提高单接口的吞吐量，这个时候你就要了解下异步编程神器CompletableFuture了，它帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合 CompletableFuture 的方法。

文章目录

前言

前言

通过阅读本篇文章你将了解到：

CompletableFuture的使用
CompletableFuture异步和同步的性能测试
已经有了Future为什么仍需要在JDK1.8中引入CompletableFuture
CompletableFuture的应用场景
对CompletableFuture的使用优化

## 场景说明查询所有商店某个商品的价格并返回，并且查询商店某个商品的价格的API为同步一个Shop类，提供一个名为getPrice的同步方法

店铺类：Shop.java

public class Shop {
   
   
    private Random random = new Random();
    /**
     * 根据产品名查找价格
     * */
    public double getPrice(String product) {
   
   
        return calculatePrice(product);
    }

    /**
     * 计算价格
     *
     * @param product
     * @return
     * */
    private double calculatePrice(String product) {
   
   
        delay();
        //random.nextDouble()随机返回折扣
        return random.nextDouble() * product.charAt(0) + product.charAt(1);
    }

    /**
     * 通过睡眠模拟其他耗时操作
     * */
    private void delay() {
   
   
        try {
   
   
            Thread.sleep(1000);
        } catch (InterruptedException e) {
   
   
            e.printStackTrace();
        }
    }
}

复制代码查询商品的价格为同步方法，并通过sleep方法模拟其他操作。这个场景模拟了当需要调用第三方API，但第三方提供的是同步API，在无法修改第三方API时如何设计代码调用提高应用的性能和吞吐量，这时候可以使用CompletableFuture类

CompletableFuture使用

Completable是Future接口的实现类，在JDK1.8中引入

CompletableFuture的创建

使用new方法

CompletableFuture<Double> futurePrice = new CompletableFuture<>();

使用CompletableFuture#completedFuture静态方法创建

public static <U> CompletableFuture<U> completedFuture(U value) {
   
   
    return new CompletableFuture<U>((value == null) ? NIL : value);
}

参数的值为任务执行完的结果，一般该方法在实际应用中较少应用

使用 CompletableFuture#supplyAsync静态方法创建supplyAsync有两个重载方法：

/方法一
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
   
   
    return asyncSupplyStage(asyncPool, supplier);
}
//方法二
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,
                                                   Executor executor) {
   
   
    return asyncSupplyStage(screenExecutor(executor), supplier);
}

使用CompletableFuture#runAsync静态方法创建runAsync有两个重载方法

//方法一
public static CompletableFuture<Void> runAsync(Runnable runnable) {
   
   
    return asyncRunStage(asyncPool, runnable);
}
//方法二
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor) {
   
   
    return asyncRunStage(screenExecutor(executor), runnable);
}

说明：

两个重载方法之间的区别 => 后者可以传入自定义Executor，前者是默认的，使用的ForkJoinPool
supplyAsync和runAsync方法之间的区别 => 前者有返回值，后者无返回值
Supplier是函数式接口，因此该方法需要传入该接口的实现类，追踪源码会发现在run方法中会调用该接口的方法。因此使用该方法创建- CompletableFuture对象只需重写Supplier中的get方法，在get方法中定义任务即可。又因为函数式接口可以使用Lambda表达式，和new创建CompletableFuture对象相比代码会简洁不少

结果的获取

对于结果的获取CompltableFuture类提供了四种方式

//方式一
public T get()
//方式二
public T get(long timeout, TimeUnit unit)
//方式三
public T getNow(T valueIfAbsent)
//方式四
public T join()

说明：

get()和get(long timeout, TimeUnit unit) => 在Future中就已经提供了，后者提供超时处理，如果在指定时间内未获取结果将抛出超时异常
getNow => 立即获取结果不阻塞，结果计算已完成将返回结果或计算过程中的异常，如果未计算完成将返回设定的valueIfAbsent值
join => 方法里不会抛出异常

示例：

public class AcquireResultTest {
   
   
    public static void main(String[] args) throws ExecutionException, InterruptedException {
   
   
        //getNow方法测试
        CompletableFuture<String> cp1 = CompletableFuture.supplyAsync(() -> {
   
   
            try {
   
   
                Thread.sleep(60 * 1000 * 60 );
            } catch (InterruptedException e) {
   
   
                e.printStackTrace();
            }

            return "hello world";
        });

        System.out.println(cp1.getNow("hello h2t"));

        //join方法测试
        CompletableFuture<Integer> cp2 = CompletableFuture.supplyAsync((()-> 1 / 0));
        System.out.println(cp2.join());

        //get方法测试
        CompletableFuture<Integer> cp3 = CompletableFuture.supplyAsync((()-> 1 / 0));
        System.out.println(cp3.get());
    }
}