Best Practices and Pitfalls of Using Thread Pools in Java

This article provides a comprehensive guide to using Java thread pools safely and efficiently. It starts with the importance of declaring thread pools manually via ThreadPoolExecutor instead of the convenience methods in Executors, which can cause OOM due to unbounded queues.

It then describes how to monitor pool status using Spring Boot Actuator or directly via ThreadPoolExecutor APIs, showing a demo method printThreadPoolStatus() that logs pool size, active threads, completed tasks, and queue size every second.

For different business scenarios, the article recommends creating separate thread pools per service to tailor core size, max size, and queue capacity, and illustrates a real‑world deadlock case caused by reusing the same pool for parent and child tasks.

Naming thread pools is emphasized for easier troubleshooting; examples include using Guava's ThreadFactoryBuilder or a custom NamingThreadFactory to set meaningful thread name prefixes.

The piece also covers proper parameter tuning: it explains the difference between CPU‑bound and I/O‑bound workloads, provides formulas (N+1 for CPU‑intensive, 2N for I/O‑intensive), and warns against over‑provisioning which leads to excessive context switches.

Common pitfalls are listed, such as repeatedly creating new pools, misusing Spring’s internal pools, and ThreadLocal contamination when threads are reused. Solutions like Alibaba's TransmittableThreadLocal are suggested.

Finally, the article introduces dynamic configuration techniques pioneered by Meituan, including a custom resizable queue ( ResizableCapacityLinkedBlockingQueue) and runtime adjustment of corePoolSize, maximumPoolSize, and workQueue. Open‑source projects Hippo‑4 and Dynamic TP are recommended for implementing these features.

/**
 * 打印线程池的状态
 * @param threadPool 线程池对象
 */
public static void printThreadPoolStatus(ThreadPoolExecutor threadPool) {
    ScheduledExecutorService scheduledExecutorService = new ScheduledThreadPoolExecutor(1, createThreadFactory("print-images/thread-pool-status", false));
    scheduledExecutorService.scheduleAtFixedRate(() -> {
        log.info("=========================");
        log.info("ThreadPool Size: [{}]", threadPool.getPoolSize());
        log.info("Active Threads: {}", threadPool.getActiveCount());
        log.info("Number of Tasks : {}", threadPool.getCompletedTaskCount());
        log.info("Number of Tasks in Queue: {}", threadPool.getQueue().size());
        log.info("=========================");
    }, 0, 1, TimeUnit.SECONDS);
}

@GetMapping("wrong")
public String wrong() throws InterruptedException {
    ThreadPoolExecutor executor = new ThreadPoolExecutor(5,10,1L,TimeUnit.SECONDS,new ArrayBlockingQueue<>(100),new ThreadPoolExecutor.CallerRunsPolicy());
    executor.execute(() -> {
        // ...
    });
    return "OK";
}

@Configuration
@EnableAsync
public class ThreadPoolExecutorConfig {
    @Bean(name="threadPoolExecutor")
    public Executor threadPoolExecutor(){
        ThreadPoolTaskExecutor threadPoolExecutor = new ThreadPoolTaskExecutor();
        int processNum = Runtime.getRuntime().availableProcessors();
        int corePoolSize = (int) (processNum / (1 - 0.2));
        int maxPoolSize = (int) (processNum / (1 - 0.5));
        threadPoolExecutor.setCorePoolSize(corePoolSize);
        threadPoolExecutor.setMaxPoolSize(maxPoolSize);
        threadPoolExecutor.setQueueCapacity(maxPoolSize * 1000);
        threadPoolExecutor.setThreadPriority(Thread.MAX_PRIORITY);
        threadPoolExecutor.setDaemon(false);
        threadPoolExecutor.setKeepAliveSeconds(300);
        threadPoolExecutor.setThreadNamePrefix("test-Executor-");
        return threadPoolExecutor;
    }
}