Master DynamicTp: A Powerful, Monitorable Thread Pool for Spring Boot

Introduction

Environment: Spring Boot 2.7.18

When using ThreadPoolExecutor you may encounter three common pain points: not knowing the optimal core parameters, having to redeploy after parameter changes, and lacking visibility into the thread pool’s runtime behavior.

1.1 ThreadPoolExecutor Parameters

The class provides several setter and getter methods for dynamic adjustment:

public void setCorePoolSize(int corePoolSize) {}
public void setMaximumPoolSize(int maximumPoolSize) {}
public void setKeepAliveTime(long time, TimeUnit unit) {}
public void setThreadFactory(ThreadFactory threadFactory) {}
public void setRejectedExecutionHandler(RejectedExecutionHandler handler) {}
public void allowCoreThreadTimeOut(boolean value) {}
public int getCorePoolSize() {}
public int getMaximumPoolSize() {}
public long getKeepAliveTime(TimeUnit unit) {}
public BlockingQueue<Runnable> getQueue() {}
public RejectedExecutionHandler getRejectedExecutionHandler() {}
public boolean allowsCoreThreadTimeOut() {}

1.2 DynamicTp Framework

DynamicTp extends the limited functionality of JDK’s thread pool, providing the following capabilities:

Dynamic parameter modification : Change pool parameters at runtime with immediate effect.

Real‑time monitoring and alerts : Monitor pool status and push alerts to platforms such as WeChat, DingTalk, Feishu, email, etc.

Metric collection for dashboards : Periodically collect over 20 metrics for Grafana or similar visual tools.

Third‑party middleware integration : Manage thread pools of Tomcat, Jetty, Undertow, Dubbo, RocketMQ, Hystrix, gRPC, OkHttp3, and many others.

Key features of version 1.1.7 include:

Zero code intrusion : Configuration is loaded from a config center and the pool is injected via Spring, requiring no changes to business code.

Notification alerts : Multiple alert dimensions (config changes, activity, queue capacity, rejection, task timeout) with support for custom extensions.

Runtime monitoring : Collects thread‑pool, queue, and task metrics via Micrometer, JsonLog, or JMX, and exposes them via SpringBoot endpoints.

Task enhancement : Provides a powerful task wrapper interface.

Multiple config‑center support : Nacos, Apollo, Zookeeper, Consul, Etcd, Polaris, ServiceComb, plus SPI for extensions.

Middleware thread‑pool management : Integrated management for common third‑party components.

Lightweight and simple : Only a few dependencies and four steps to get started.

Multiple pool modes : DtpExecutor, EagerDtpExecutor, ScheduledDtpExecutor, OrderedDtpExecutor.

Compatibility : @DynamicTp annotation works with JUC pools and Spring’s ThreadPoolTaskExecutor.

Reliability : Graceful shutdown via Spring lifecycle.

High extensibility : SPI interfaces for custom implementations.

1.3 Architecture

2 Practical Cases

2.1 Without Config Center

Even without a config center you can still use DynamicTp for monitoring and alerts.

Dependency

<dependency>
  <groupId>org.dromara.dynamictp</groupId>
  <artifactId>dynamic-tp-spring-boot-starter-common</artifactId>
  <version>1.1.7</version>
</dependency>

Configuration (application.yml)

spring:
  dynamic:
    tp:
      enabled: true
      enabledCollect: true
      collectorTypes: micrometer,logging
      logPath: ./logs/dynamictp/
      monitorInterval: 5
      platforms:
        - platform: email
          platformId: 1
          receivers: [email protected]
      executors:
        - threadPoolName: packPool
          executorType: common
          corePoolSize: 6
          maximumPoolSize: 8
          queueCapacity: 300
          queueType: VariableLinkedBlockingQueue
          rejectedHandlerType: CallerRunsPolicy
          keepAliveTime: 60
          threadNamePrefix: task
          allowCoreThreadTimeOut: false
          notifyEnabled: true
          platformIds: [1]
          notifyItems:
            - type: change
              enabled: true
            - type: capacity
              enabled: true
              threshold: 40
              platformIds: [1]
              interval: 120

Enable DynamicTp

@SpringBootApplication
@EnableDynamicTp
public class AppApplication {
    public static void main(String[] args) {
        SpringApplication.run(AppApplication.class, args);
    }
}

After starting the application you will see logs confirming the framework is active.

Bean Definition Example

@Bean
@DynamicTp
ThreadPoolExecutor packPoolExector() {
    return new ThreadPoolExecutor(10, 10, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
}

@Bean
@DynamicTp
ThreadPoolTaskExecutor packTaskExecutor() {
    return new ThreadPoolTaskExecutor();
}

Inject the pool via @Resource , @Autowired , constructor injection, or DtpRegistry.getExecutor("name") .

Component Using the Pool

@Component
public class PackTaskComponent {
    private final AtomicInteger count = new AtomicInteger(0);
    private final ThreadPoolExecutor packPoolExector;
    public PackTaskComponent(ThreadPoolExecutor packPoolExector) {
        this.packPoolExector = packPoolExector;
    }
    @PostConstruct
    public void task() {
        new Thread(() -> {
            while (true) {
                packPoolExector.execute(() -> {
                    System.err.printf("Current thread: %s, task %d%n", Thread.currentThread().getName(), count.incrementAndGet());
                    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {}
                });
                try { TimeUnit.MILLISECONDS.sleep(1500); } catch (InterruptedException e) {}
            }
        }).start();
    }
}

Logs show task execution and pool activity.

2.2 With Nacos Config Center

Dependency

<dependency>
  <groupId>org.dromara.dynamictp</groupId>
  <artifactId>dynamic-tp-spring-boot-starter-nacos</artifactId>
  <version>1.1.7</version>
</dependency>

Nacos Configuration (application.yml)

nacos:
  config:
    server-addr: localhost:8848
    type: yaml
    data-ids: myapp-threadpool-config.yml
    auto-refresh: true
    group: DEFAULT_GROUP
    bootstrap:
      enable: true
      log-enable: true

Define the thread‑pool configuration in Nacos under the specified Data ID.

After modifying parameters in Nacos, the application logs reflect the changes in real time.

Metrics can be visualized in Grafana.

The dynamic adjustment via the config center works successfully.

Conclusion

This article demonstrated how DynamicTp provides a zero‑intrusion, highly configurable, and monitorable thread‑pool solution for Spring Boot applications, supporting both standalone and Nacos‑based configuration scenarios.