Nacos配合SpringBoot实现动态线程池的基本步骤

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

spring:
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848 # Nacos服务地址
        namespace: your-namespace # Nacos命名空间
        file-extension: yaml # 配置文件类型

@Configuration
public class ThreadPoolConfig {

    @Value("${thread.pool.core-size}")
    private int coreSize;

    @Value("${thread.pool.max-size}")
    private int maxSize;

    @Value("${thread.pool.queue-capacity}")
    private int queueCapacity;

    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(coreSize);
        executor.setMaxPoolSize(maxSize);
        executor.setQueueCapacity(queueCapacity);
        executor.initialize();
        return executor;
    }
}

thread:
  pool:
    core-size: 10
    max-size: 20
    queue-capacity: 100

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "thread.pool")
public class ThreadPoolProperties {
    private int coreSize;
    private int maxSize;
    private int queueCapacity;

    // Getters and setters
    public int getCoreSize() {
        return coreSize;
    }

    public void setCoreSize(int coreSize) {
        this.coreSize = coreSize;
    }

    public int getMaxSize() {
        return maxSize;
    }

    public void setMaxSize(int maxSize) {
        this.maxSize = maxSize;
    }

    public int getQueueCapacity() {
        return queueCapacity;
    }

    public void setQueueCapacity(int queueCapacity) {
        this.queueCapacity = queueCapacity;
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.EventListener;
import org.springframework.cloud.context.scope.refresh.RefreshScopeRefreshedEvent;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;

@Configuration
public class ThreadPoolConfig {

    @Autowired
    private ThreadPoolProperties properties;

    private ThreadPoolTaskExecutor executor;

    @Bean
    public ThreadPoolTaskExecutor taskExecutor() {
        executor = new ThreadPoolTaskExecutor();
        updateThreadPoolExecutor(properties);
        return executor;
    }

    @EventListener(RefreshScopeRefreshedEvent.class)
    public void onRefresh(RefreshScopeRefreshedEvent event) {
        updateThreadPoolExecutor(properties);
    }


    // 假设这是一个成员变量，用于持有当前的线程池实例
    private volatile ThreadPoolTaskExecutor executor;

    private void updateThreadPoolExecutor(ThreadPoolProperties properties) {
        if (executor != null) {
            // 安全关闭现有的线程池
            shutdownAndAwaitTermination(executor.getThreadPoolExecutor());
        }

        // 使用新的配置参数创建并初始化一个新的线程池实例
        ThreadPoolTaskExecutor newExecutor = new ThreadPoolTaskExecutor();
        newExecutor.setCorePoolSize(properties.getCoreSize());
        newExecutor.setMaxPoolSize(properties.getMaxSize());
        newExecutor.setQueueCapacity(properties.getQueueCapacity());
        newExecutor.setThreadNamePrefix("custom-executor-");
        newExecutor.initialize();

        // 更新引用，使用新的线程池实例
        this.executor = newExecutor;
    }

    private void shutdownAndAwaitTermination(Executor executor) {
        if (executor instanceof java.util.concurrent.ThreadPoolExecutor) {
            java.util.concurrent.ThreadPoolExecutor threadPool = (java.util.concurrent.ThreadPoolExecutor) executor;
            threadPool.shutdown(); // 禁止提交新任务
            try {
                // 等待一段时间以终止现有任务
                if (!threadPool.awaitTermination(30, TimeUnit.SECONDS)) {
                    threadPool.shutdownNow(); // 取消当前正在执行的任务
                    // 等待一段时间，等待任务对取消做出响应
                    if (!threadPool.awaitTermination(30, TimeUnit.SECONDS))
                        System.err.println("线程池未完全终止");
                }
            } catch (InterruptedException ie) {
                // （重新-）如果当前线程也中断，则取消
                threadPool.shutdownNow();
                // 保留中断状态
                Thread.currentThread().interrupt();
            }
        }
    }
}