Dynamic thread pool management addresses concurrency bottlenecks by allowing runtime adjustments to executor parameters without service restarts. Integrating this capability with Nacos provides a centralized, low-latency mechanism for propagating configuration changes across distributed microservices. The architecture relies on three core components: a local ThreadPoolExecutor instance, a Nacos configuration namespace for persistent parameter storage, and an event-driven listener that bridges remote state changes with local thread pool mutations.

Configuration Hierarchy and Data Identifier Scheme Spring Boot initializes externalized configuration through a defined precedence chain. When Nacos is utilized as the remote configuration source, the initialization phase prioritizes bootstrap.yml to establish connection parameters before merging with application.yml or environment-specific profiles. The Data ID used by Nacos follows a deterministic template: {spring.application.name}-{spring.profiles.active}.{file-extension}. This pattern ensures that each deployment environment maps to an isolated configuration document, preventing cross-environment parameter leakage.

For a service named task-orchestrator running in a development profile with YAML formatting, the target configuration key resolves to task-orchestrator-dev.yml. Within this document, executor metrics are stored under structured keys:

thread-pool:
  core-minimum: 4
  core-maximum: 16
  queue-capacity: 256

Implementation Architecture The runtime integration requires a configuration bean that fulfills two responsibilities: instantiating the executor upon context bootstrapping and registering a continuous watch on the target Nacos document. Spring Cloud's @RefreshScope annotation enables contextual recreation of beans when remote properties shift, but direct field injection often misses late-stage listener events. Consequently, explicit subscription via NacosConfigService.addListener offers finer control over parsing and mutation cycles.

Upon receiving a payload, the subscriber deserializes the updated metrics, validates boundary constraints, and invokes setter methods on the active ThreadPoolExecutor. Since ThreadPoolExecutor lacks atomic mutators for all parameters, direct assignment to corePoolSize and maximumPoolSize triggers immediate internal rebalancing without interrupting currently executing tasks.

Core Configuration Module

package com.architecture.executor;

import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.config.listener.Listener;
import com.alibaba.nacos.api.exception.NacosException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.concurrent.*;
import java.util.Properties;
import java.util.concurrent.atomic.AtomicInteger;

@Slf4j
@RefreshScope
@Component
public class AdaptiveThreadPoolRegistry {

    private ThreadPoolExecutor adaptiveExecutor;
    private int currentMinThreads;
    private int currentMaxThreads;

    @Value("${thread-pool.core-minimum}")
    private String configMinThreads;

    @Value("${thread-pool.core-maximum}")
    private String configMaxThreads;

    @PostConstruct
    public void initializeExecutor() throws NacosException {
        initLocalInstance();
        subscribeRemoteChanges();
    }

    private void initLocalInstance() {
        currentMinThreads = Integer.parseInt(configMinThreads);
        currentMaxThreads = Integer.parseInt(configMaxThreads);

        adaptiveExecutor = new ThreadPoolExecutor(
            currentMinThreads,
            currentMaxThreads,
            60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(256),
            new CustomThreadFactory(),
            new AbortPolicyWithMetrics()
        );
        log.info("Adaptive pool initialized | Min: {}, Max: {}", currentMinThreads, currentMaxThreads);
    }

    private void subscribeRemoteChanges() throws NacosException {
        Properties nacosProps = new Properties();
        nacosProps.put("serverAddr", "127.0.0.1:8848");
        nacosProps.put("namespace", "public");

        ConfigService configService = NacosFactory.createConfigService(nacosProps);
        String dataId = "task-orchestrator-dev.yml";
        String group = "DEFAULT_GROUP";

        configService.addListener(dataId, group, new Listener() {
            @Override
            public Executor getExecutor() { return null; }

            @Override
            public void receiveConfigInfo(String rawConfig) {
                try {
                    parseAndApplyConfig(rawConfig);
                } catch (Exception e) {
                    log.error("Failed to apply remote thread pool configuration", e);
                }
            }
        });
        log.info("Registered watcher for {}", dataId);
    }

    private void parseAndApplyConfig(String yamlPayload) {
        String minMatch = yamlPayload.contains("core-minimum:") 
            ? yamlPayload.split("core-minimum:")[1].trim().split("\\n")[0] 
            : String.valueOf(currentMinThreads);
                
        String maxMatch = yamlPayload.contains("core-maximum:") 
            ? yamlPayload.split("core-maximum:")[1].trim().split("\\n")[0] 
            : String.valueOf(currentMaxThreads);

        int newMin = Math.max(1, Integer.parseInt(minMatch));
        int newMax = Math.max(newMin, Integer.parseInt(maxMatch));

        if (newMin != currentMinThreads || newMax != currentMaxThreads) {
            log.info("Applying remote mutation | New Core: {} -> {}, New Max: {} -> {}", 
                     currentMinThreads, newMin, currentMaxThreads, newMax);
                
            synchronized (adaptiveExecutor) {
                adaptiveExecutor.setCorePoolSize(newMin);
                adaptiveExecutor.setMaximumPoolSize(newMax);
            }
                
            currentMinThreads = newMin;
            currentMaxThreads = newMax;
        }
    }

    public void submitBatchTasks(int taskCount) {
        for (int i = 0; i < taskCount; i++) {
            final int taskId = i;
            adaptiveExecutor.execute(() -> simulateProcessing(taskId));
        }
    }

    private void simulateProcessing(int id) {
        try {
            Thread.sleep(500);
            log.debug("Task {} completed execution", id);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    public ExecutorRuntimeStatus getStatusSnapshot() {
        return new ExecutorRuntimeStatus(
            adaptiveExecutor.getCorePoolSize(),
            adaptiveExecutor.getActiveCount(),
            adaptiveExecutor.getMaximumPoolSize(),
            adaptiveExecutor.getQueue().size(),
            adaptiveExecutor.getCompletedTaskCount()
        );
    }

    public static class ExecutorRuntimeStatus {
        public int coreSize, activeThreads, maxSize, queuedTasks, totalCompleted;
        public ExecutorRuntimeStatus(int c, int a, int m, int q, int tc) {
            this.coreSize = c; this.activeThreads = a; this.maxSize = m; 
            this.queuedTasks = q; this.totalCompleted = tc;
        }
    }

    private static class CustomThreadFactory implements ThreadFactory {
        private final AtomicInteger counter = new AtomicInteger(1);
        @Override public Thread newThread(Runnable r) {
            return new Thread(r, "exec-worker-" + counter.getAndIncrement());
        }
    }

    private static class AbortPolicyWithMetrics implements RejectedExecutionHandler {
        @Override public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            log.warn("Executor overflow detected | Active: {}, Queue: {}", e.getActiveCount(), e.getQueue().size());
            throw new RejectedExecutionException("System under heavy load, reject received.");
        }
    }
}

RESTful Exposure Layer Controllers expose operational endpoints that delegate to the registry. This decouples infrastructure management from business logic and allows external orchestrators or operators to probe state dynamically.

package com.architecture.endpoint;

import com.architecture.executor.AdaptiveThreadPoolRegistry;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/v1/pool")
public class PoolManagementController {

    private final AdaptiveThreadPoolRegistry registry;

    public PoolManagementController(AdaptiveThreadPoolRegistry registry) {
        this.registry = registry;
    }

    @GetMapping("/metrics")
    public AdaptiveThreadPoolRegistry.ExecutorRuntimeStatus queryStatus() {
        return registry.getStatusSnapshot();
    }

    @PostMapping("/submit")
    public String dispatchWork(@RequestParam(defaultValue = "10") int volume) {
        registry.submitBatchTasks(volume);
        return String.format("Dispatched %d asynchronous jobs", volume);
    }
}

Operational Workflow Validation involves deploying the service alongside the Nacos server, verifying initial registration through the /api/v1/pool/metrics endpoint, and injecting load via /api/v1/pool/submit. Modifying core-minimum or core-maximum with in the Nacos console triggers the registered listener. The application logs reflect immediate parameter rotation without downtime. Observability tools can track queue depth and active thread fluctuations correlated with the configuration payload.