CompletableFuture避坑2——allOf()超时时

CompletableFuture避坑1——需要自定义线程池
CompletableFuture避坑2——allOf()超时时间不合理的后果
CompletableFuture避坑3——线程池的DiscardPolicy()导致整个程序卡死

运行下面这段程序

import com.alibaba.fastjson.JSONObject;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolTest {

    private static final Logger log = LoggerFactory.getLogger(ThreadPoolTest.class);

    public static void main(String[] args) {
        List<CompletableFuture> futures = new ArrayList<>(3);
        CompletableFuture first = CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(5000);
                System.out.println("first");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).exceptionally(e -> {
            e.printStackTrace();
            return null;
        });
        futures.add(first);
        Long startTime = System.currentTimeMillis();
        log.info("开始等待所有线程结束，时间：{}", startTime);
        try {
            CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).orTimeout(2000, TimeUnit.MILLISECONDS).join();
        } catch (Exception e) {
            log.error("等待所有线程结束发生异常：", e);
        } finally {
            Long endTime = System.currentTimeMillis();
            log.info("等待结束，时间：{}, 耗时：{}秒", startTime, (endTime-startTime)/1000);
            try {
                log.info(JSONObject.toJSONString(first));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

输出

10:57:59.612 [main] INFO com.example.demo.ThreadPoolTest2 - 开始等待所有线程结束，时间：1627268279609
10:58:01.642 [main] ERROR com.example.demo.ThreadPoolTest2 - 等待所有线程结束发生异常：
java.util.concurrent.CompletionException: java.util.concurrent.TimeoutException
    at java.base/java.util.concurrent.CompletableFuture.reportJoin(CompletableFuture.java:412)
    at java.base/java.util.concurrent.CompletableFuture.join(CompletableFuture.java:2044)
    at com.example.demo.ThreadPoolTest2.main(ThreadPoolTest2.java:46)
Caused by: java.util.concurrent.TimeoutException: null
    at java.base/java.util.concurrent.CompletableFuture$Timeout.run(CompletableFuture.java:2792)
    at java.base/java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:515)
    at java.base/java.util.concurrent.FutureTask.run(FutureTask.java:264)
    at java.base/java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:304)
    at java.base/java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1128)
    at java.base/java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:628)
    at java.base/java.lang.Thread.run(Thread.java:834)
10:58:01.643 [main] INFO com.example.demo.ThreadPoolTest2 - 等待结束，时间：1627268279609, 耗时：2秒
10:58:01.726 [main] INFO com.example.demo.ThreadPoolTest2 - {"cancelled":false,"completedExceptionally":false,"done":false,"numberOfDependents":2}
10:58:04.309 [HomePageCardFeatureQueryThreadPool-0] INFO com.example.demo.ThreadPoolTest2 - 线程first结束

可以看到，设置allof的等待时间（2s）比线程实际执行时间（5s）短，等待超时结束时，线程并没有被杀死，也没有被取消，也没有抛异常，这个线程继续运行着，直到正常结束。
这会有什么问题呢？
如果接口中存在这种代码，大量请求超时返回，但是实际子线程还在运行，接口又接收更多的请求，继续创建子线程（没有使用线程池）或者进入线程池排队，前者会导致 OOM，后者则会加剧接口超时（任务都在排队，等不到执行）导致接口乃至整个服务完全不可用。
实际代码中我们有很多io操作，一般都会设置超时时间（不设置的后果很严重），如果子线程中调用了这些方法，那么allof()方法的超时时间一定要大于最大的超时时间（如果有串行操作，还需要累加）。