问题描述

最近刚刚上线的服务突然抛出大量的TimeoutException，查询后发现是使用了CompletableFuture，并且在执行future.get(5, TimeUnit.SECONDS);时抛出了TimeoutException异常，导致接口响应很慢进而影响了其他系统的调用。

问题分析

首先我们知道CompletableFuture的get()方法值会阻塞主线程，直到子线程执行任务完成返回结果才会取消阻塞。如果子线程一直不返回接口那么主线程就会一直阻塞，所以我们一般不建议直接使用CompletableFuture的get()方法，而是使用future.get(5, TimeUnit.SECONDS);方法指定超时时间。

但是当我们的线程池拒绝策略使用的是DiscardPolicy或者DiscardOldestPolicy，并且线程池饱和了的时候，我们将会直接丢弃任务，不会抛出任何异常。这个时候再来调用get方法是主线程就会一直等待子线程返回结果，直到超时抛出TimeoutException。

我们来看下面一段代码：

@RunWith(SpringRunner.class)
@SpringBootTest
public class CompletableFutureTest {
    Logger logger = LoggerFactory.getLogger(CompletableFutureTest.class);
    ThreadPoolTaskExecutor taskExecutor = null;

    @Before
    public void before() {
        taskExecutor = new ThreadPoolTaskExecutor();
        // 核心线程数
        taskExecutor.setCorePoolSize(1);
        // 最大线程数
        taskExecutor.setMaxPoolSize(1);
        // 队列最大长度
        taskExecutor.setQueueCapacity(2);
        // 线程池维护线程所允许的空闲时间(单位秒)
        taskExecutor.setKeepAliveSeconds(60);
        /*
         * 线程池对拒绝任务(无限程可用)的处理策略
         * ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
         * ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
         * ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
         * ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务,如果执行器已关闭,则丢弃.
         */
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
        taskExecutor.initialize();
    }

    @Test
    public void testGet() throws Exception {
        for (int i = 1; i < 100; i++) {
            new Thread(() -> {
                // 第一步非常耗时，会沾满线程池
                taskExecutor.execute(() -> {
                    sleep(5000);
                });

                // 第二步不耗时的操作，但是get的时候会报TimeoutException
                CompletableFuture<Object> future1 = CompletableFuture.supplyAsync(() -> 1, taskExecutor);
                CompletableFuture<Object> future2 = CompletableFuture.supplyAsync(() -> 2, taskExecutor);
                try {
                    System.out.println(Thread.currentThread().getName() + "::value1" + future1.get(1, TimeUnit.SECONDS));
                    System.out.println(Thread.currentThread().getName() + "::value2" + future2.get(1, TimeUnit.SECONDS));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }


        sleep(30000);
    }

    /**
     * @param millis 毫秒
     * @Title: sleep
     * @Description: 线程等待时间
     * @author yuhao.wang
     */
    private void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            logger.info("获取分布式锁休眠被中断：", e);
        }
    }
}

我们可以看到第一步的异步线程时一个非常耗时的线程，第二步的两个CompletableFuture是一个非常快的异步操作。按照道理来说future1.get(1, TimeUnit.SECONDS)这一步是不因该报TimeOut的。但是我们发现我们线程池拒绝策略使用的是DiscardPolicy，当线程池满了会直接丢弃任务，而不会终止主线程。这个时候执行get方法的时候，主线线程一直会等待直到超时为止。所以接口响应速度一下就慢了下来。

解决方案

1. 在使用CompletableFuture时线程池拒绝策略最好使用AbortPolicy。直接中断主线程，达到快速失败的效果。
2. 耗时的异步线程和CompletableFuture的线程做线程池隔离，让耗时操作不影响主线程的执行

总结

1. 在使用CompletableFuture的时候线程池拒绝策略最好使用AbortPolicy，如果线程池满了直接抛出异常中断主线程，达到快速失败的效果
2. 耗时的异步线程和CompletableFuture的线程做线程池隔离，让耗时操作不影响主线程的执行
3. 不建议直接使用CompletableFuture的get()方法，而是使用future.get(5, TimeUnit.SECONDS);方法指定超时时间

源码

https://github.com/wyh-spring-ecosystem-student/spring-boot-student/tree/releases

spring-boot-student-completable-future 工程

为监控而生的多级缓存框架 layering-cache这是我开源的一个多级缓存框架的实现，如果有兴趣可以看一下。