Designing a Dynamic Thread Pool for a Meituan Interview: Concepts and Implementation

This article originates from a Meituan interview scenario and walks through the design of a simple dynamic thread pool.

What is a Dynamic Thread Pool and Why Is It Needed?

A dynamic thread pool can adjust core configuration parameters (e.g., core thread count, maximum thread count) in real time without restarting the service. Traditional pools suffer from three main pain points:

Parameters cannot be changed dynamically : corePoolSize, maximumPoolSize, and queue size are fixed at creation, requiring service restarts when load changes.

Insufficient monitoring : No built‑in metrics to detect task backlog, thread saturation, or rejection events.

Difficult troubleshooting : When rejections or deadlocks occur, stack traces are not readily available, hindering root‑cause analysis.

Dynamic pools address these issues by allowing real‑time parameter adjustments, embedding monitoring and alerting, and providing runtime stack retrieval for easier debugging.

Key Parameters for Dynamic Configuration

According to Meituan’s technical article "Java Thread Pool Implementation Principles and Practices in Meituan Business", the three most important parameters of ThreadPoolExecutor are: corePoolSize: Minimum number of threads that stay alive. maximumPoolSize: Upper bound of concurrent threads when the queue is full. workQueue: The task queue; new tasks are queued here once the core size is reached.

These parameters fundamentally determine the pool’s task‑handling strategy, as also noted in the "Java Thread Pool Detailed Guide".

How to Support Dynamic Parameter Updates

ThreadPoolExecutor

offers setter methods such as setCorePoolSize(). When invoking setCorePoolSize(), the pool first checks whether the current number of active threads exceeds the new core size; if so, excess threads are reclaimed.

Because ThreadPoolExecutor does not expose a dynamic queue‑size setter, Meituan implements a custom ResizableCapacityLinkedBlockingQueue by removing the final modifier from the capacity field of LinkedBlockingQueue, making the queue size mutable.

Configuration Sources

Parameters can be stored in a configuration center (e.g., Nacos, Apollo, Zookeeper). Applications read the values at startup and listen for changes to apply them instantly. If a configuration center is not desired, file‑watching utilities such as Hutool’s WatchMonitor (based on WatchService) or Apache Commons IO’s FileAlterationListenerAdaptor can detect modifications to a local properties file and trigger updates.

Retrieving Thread‑Pool Metrics

The following ThreadPoolExecutor methods provide basic metrics:

getCorePoolSize()

getMaximumPoolSize()

getPoolSize()

getQueue()

getActiveCount()

getLargestPoolSize()

getTaskCount()

Hook methods such as beforeExecute(Thread t, Runnable r), afterExecute(Runnable r, Throwable t), and terminated() can be overridden for custom logging or resource cleanup.

Simple Monitoring Demo

The following demo prints pool size, active threads, completed tasks, and queue size every second:

/**
 * Print thread‑pool status
 * @param threadPool the ThreadPoolExecutor instance
 */
public static void printThreadPoolStatus(ThreadPoolExecutor threadPool) {
    ScheduledExecutorService scheduledExecutorService = new ScheduledThreadPoolExecutor(1, createThreadFactory("print-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);
}

For production‑grade monitoring, Spring Boot Actuator can expose metrics, but a custom Endpoint is often preferred for flexibility.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

A simplified custom endpoint exposing core metrics looks like this:

// Simplified example exposing core information
@Component
@Endpoint(id = "threadpool")
public class ThreadPoolEndpoint {

    @Autowired
    private ThreadPoolManager threadPoolManager;

    @ReadOperation
    public Map<String, Object> threadPoolsMetric() {
        Map<String, Object> metricMap = new HashMap<>();
        Map<String, Map<String, Object>> threadPools = new HashMap<>();
        threadPoolManager.getThreadPoolExecutorMap().forEach((name, executor) -> {
            MonitorThreadPool tpe = (MonitorThreadPool) executor;
            Map<String, Object> poolInfo = new HashMap<>();
            poolInfo.put("coreSize", tpe.getCorePoolSize());
            poolInfo.put("maxSize", tpe.getMaximumPoolSize());
            poolInfo.put("activeCount", tpe.getActiveCount());
            poolInfo.put("taskCount", tpe.getTaskCount());
            threadPools.put(name, poolInfo);
        });
        metricMap.put("threadPools", threadPools);
        return metricMap;
    }
}

After exposing the endpoint, the metrics are reachable at /actuator/threadpool (ensure management.endpoints.web.exposure.include=*).

{
  "threadPools": {
    "pool1": {"coreSize": 10, "maxSize": 20, "activeCount": 5, "taskCount": 100},
    "pool2": {"coreSize": 5, "maxSize": 10, "activeCount": 2, "taskCount": 50}
  }
}

Visualization and Alerting

Prometheus + Grafana is the most common stack for visualizing these metrics and setting up alerts. The open‑source project Dynamic TP already integrates with Prometheus and Grafana, as illustrated in the accompanying screenshot.

Other monitoring systems such as HertzBeat and Cubic can also be used.

Open‑Source Dynamic Thread‑Pool Implementations

Hippo4j : Asynchronous thread‑pool framework supporting dynamic changes, monitoring, and alerts without code modifications.

Dynamic TP : Lightweight dynamic pool with built‑in monitoring, alerting, and integration with major configuration centers (Nacos, Apollo, Zookeeper, Consul, Etcd) and SPI for custom extensions.

References

[1] "Java Thread Pool Implementation Principles and Practices in Meituan Business" – https://tech.meituan.com/2020/04/02/java-pooling-pratice-in-meituan.html

[2] "Java Thread Pool Detailed Guide" – https://javaguide.cn/java/concurrent/java-thread-pool-summary.html

[3] HertzBeat – https://gitee.com/hertzbeat/hertzbeat

[4] Cubic – https://gitee.com/dromara/cubic

[5] Hippo4j – https://github.com/opengoofy/hippo4j

[6] Dynamic TP – https://github.com/dromara/dynamic-tp