$ show dromara/dynamic-tp
DynamicTp is a Java library for dynamic thread pool management, primarily targeting Spring Boot applications. It allows runtime modification of thread pool parameters (core size, max size, queue capacity, etc.) via configuration centers like Nacos, Apollo, Zookeeper, Consul, Etcd, and Polaris. The library provides a rich set of executor variants (eager, ordered, priority, scheduled) and integrates with over a dozen middleware frameworks (Dubbo, gRPC, RocketMQ, RabbitMQ, Tomcat, Jetty, Undertow, Hystrix, Motan, OkHttp3, Thrift, SofaRPC, Tars, LiteFlow, brpc) by wrapping their native thread pools. It includes comprehensive monitoring and alerting: metrics collection via Micrometer, JMX, and logging; notification channels for DingTalk, WeChat, Lark, email, and custom notifiers; and alarm thresholds for capacity, liveness, rejections, and timeouts. The architecture is modular: a core module defines executors, registries, and lifecycle management; a common module provides utilities, parsers, queues, and SPI extension points; adapter modules wrap middleware executors; starter modules provide Spring Boot auto-configuration; and extension modules add optional features like Redis rate limiting and OpenTelemetry tracing. Key entry points are the @EnableDynamicTp annotation, DtpRegistry for executor registration, and ThreadPoolBuilder for programmatic pool creation. External dependencies include Spring Boot, Guava EventBus, ByteBuddy (for interception), Micrometer, and various config-center client libraries.
The LLM identified 5 files worth highlighting for reuse:
A LinkedBlockingQueue variant that dynamically adjusts its effective capacity based on available free memory. It uses a MemoryLimitCalculator that periodically refreshes the free memory threshold, and the queue's offer() method rejects elements if adding them would exceed the memory limit. This is a self-contained, reusable component for preventing OutOfMemory errors in producer-consumer scenarios, applicable to any Java application needing memory-aware backpressure.
Implements a generic filter chain (InvokerChain) where each Invoker wraps the next, allowing pre/post processing. The chain is built by InvokerChainFactory from a list of Filter instances. This pattern is used for notification processing (alarm/notice filtering) but is framework-agnostic and can be extracted for any pipeline processing need. It demonstrates clean separation of concerns and extensibility.
A high-performance timer implementation based on a hashed wheel (similar to Netty's HashedWheelTimer). It supports scheduling TimerTask instances with configurable tick duration and wheel size, and uses weak references to avoid preventing garbage collection. This is a reusable, self-contained scheduling component that can be used in any Java project requiring efficient timeout management, originally adapted from Dubbo's timer.
Defines a generic interface ExecutorAdapter<E extends Executor> that provides a uniform view over heterogeneous executor implementations (ThreadPoolExecutor, Tomcat's ThreadPool, Jetty's QueuedThreadPool, Undertow's EnhancedQueueExecutor, etc.). It includes default methods for common operations like getCorePoolSize, getMaximumPoolSize, getQueueSize, and getRejectedCount, with an UnsupportedBlockingQueue fallback for executors that don't support queue inspection. This abstraction is key to DynamicTp's middleware integration and can be reused in any project needing to manage different thread pool types uniformly.
A utility for loading implementations of a given interface using Java's ServiceLoader mechanism. It caches loaded instances and provides methods to get all implementations or a specific one by name. This is used throughout DynamicTp to discover pluggable components (config parsers, notifiers, collectors, task wrappers). It is a clean, reusable SPI loader that can be extracted for any Java project needing a simple plugin system.