DynamicTp Startup and Configuration Change Flow: A Deep Dive into Dynamic Thread Pool Design

In modern high‑concurrency applications a static thread pool quickly becomes a bottleneck as traffic and resource pressure change. DynamicTp is an open‑source component that enables hot‑adjustable thread‑pool parameters via configuration centers such as Nacos or Apollo, without restarting services.

Starter Entry Points

The component becomes active through two Maven dependencies:

<dependency>
    <groupId>com.alibaba.boot</groupId>
    <artifactId>nacos-config-spring-boot-starter</artifactId>
    <version>0.2.12</version>
</dependency>
<dependency>
    <groupId>org.dromara.dynamictp</groupId>
    <artifactId>dynamic-tp-spring-boot-starter-nacos</artifactId>
    <version>1.1.9.1</version>
</dependency>

These bring in the dynamic-tp-spring-boot-starter-common module, whose services folder declares the SPI implementation SpringBootPropertiesBinder. The binder’s bindDtpProperties method maps external Map or Environment data to DtpProperties, handling both Spring Boot 2.x and 1.x.

The spring.factories file registers the startup class DtpBootBeanConfiguration and the initialization class DtpBaseBeanConfiguration. The former loads the latter, which defines a monitoring endpoint.

Processing @EnableDynamicTp

The annotation imports three classes via its selectImports method:

public String[] selectImports(AnnotationMetadata metadata) {
    return !BooleanUtils.toBoolean(
        this.environment.getProperty("spring.dynamic.tp.enabled", "true"))
        ? new String[0]
        : new String[]{
            DtpBaseBeanDefinitionRegistrar.class.getName(),
            DtpBeanDefinitionRegistrar.class.getName(),
            DtpBaseBeanConfiguration.class.getName()
        };
}

DtpBaseBeanDefinitionRegistrar

registers three beans into the IOC container. DtpBeanDefinitionRegistrar creates an empty DtpProperties, binds the environment (which already contains Nacos‑fetched configuration), and registers each thread‑pool definition into the container:

executors.forEach(e -> {
    if (e.isAutoCreate()) {
        Class<?> executorTypeClass = ExecutorType.getClass(e.getExecutorType());
        Map<String, Object> propertyValues = this.buildPropertyValues(e);
        Object[] args = this.buildConstructorArgs(executorTypeClass, e);
        SpringBeanHelper.register(registry, e.getThreadPoolName(), executorTypeClass, propertyValues, args);
    }
});

Configuration Change Notification

When a Nacos configuration changes, NacosRefresher (registered via spring.factories) receives a NacosConfigEvent. It calls the parent AbstractRefresher.refresh, which binds the new environment and triggers DtpRegistry.refresh.

The core doRefresh method obtains the old and new main fields of the thread‑pool via ExecutorConverter.toMainFields, then computes the differences:

List<FieldInfo> diffFields = EQUATOR.getDiffFields(oldFields, newFields);
List<String> diffKeys = StreamUtil.fetchProperty(diffFields, FieldInfo::getFieldName);
NoticeManager.tryNoticeAsync(executorWrapper, oldFields, diffKeys);

EQUATOR

is a third‑party library that diffs two objects. The resulting diffKeys are passed to NoticeManager, which builds an asynchronous notification chain (e.g., Feishu messages) to alert about the changes.

Parameter Refresh Logic

The doRefreshPoolSize method first checks whether the maximum size is decreasing; if so, it adjusts the core size before the max to avoid illegal‑argument exceptions. Queue updates are handled by updateQueueProps, which replaces the default LinkedBlockingQueue (fixed capacity) with a VariableLinkedBlockingQueue that can change its capacity at runtime.

Graceful Shutdown

Because DynamicTp tightly integrates with Spring’s lifecycle, its shutdown logic waits for tasks to finish, ensuring a smooth service stop.

Design Takeaways

The component demonstrates zero‑intrusion design (business code does not need to manage pools directly), rich monitoring via Micrometer or JMX, extensible SPI for custom configuration sources, notification channels, and task wrappers, as well as integration with third‑party middleware (Dubbo, RocketMQ, Tomcat, Jetty) through dedicated adapters.

By studying the source, readers can learn how to implement hot‑parameter tuning, safe pool‑size adjustments, dynamic queue capacity, and robust change‑notification mechanisms in their own systems.