线程池动态调整

TPBoreas

已于 2025-01-08 09:07:51 修改

阅读量754

点赞数 9

文章标签： java servlet 前端

于 2025-01-08 09:06:02 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_46228563/article/details/144999105

版权

为什么需要动态调整线程池？

想象一下这样的场景：在电商系统中，平时的订单量可能比较平稳，但在促销活动期间，订单量会突然暴增。如果线程池的参数始终保持不变，要么会在平时造成资源浪费，要么会在高峰期无法应对大量请求。这时候，我们就需要能够动态调整线程池的参数。

动态调整的关键参数

线程池中可以动态调整的主要参数包括：

核心线程数(corePoolSize)
最大线程数(maximumPoolSize)
任务队列容量(workQueue capacity)
拒绝策略(RejectedExecutionHandler)

实现动态调整的方案

下面我们来看一个具体的实现方案，首先创建一个可以动态调整的线程池：


public class DynamicThreadPool {
    private ThreadPoolExecutor executor;
    private final AtomicLong totalTasks = new AtomicLong(0);
    private final AtomicLong completedTasks = new AtomicLong(0);
    
    public DynamicThreadPool(int corePoolSize, int maximumPoolSize, 
            long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        
        // 创建线程池，使用自定义的线程工厂
        executor = new ThreadPoolExecutor(
            corePoolSize,
            maximumPoolSize,
            keepAliveTime,
            unit,
            workQueue,
            new ThreadFactory() {
                private final AtomicInteger threadNumber = new AtomicInteger(1);
                
                @Override
                public Thread newThread(Runnable r) {
                    Thread t = new Thread(r, "DynamicPool-Thread-" + threadNumber.getAndIncrement());
                    // 设置为非守护线程
                    t.setDaemon(false);
                    return t;
                }
            }
        );
        
        // 添加任务执行监控
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    }
    
    // 动态调整核心线程数
    public void adjustCorePoolSize(int newCorePoolSize) {
        if (newCorePoolSize < 0) {
            throw new IllegalArgumentException("Core pool size cannot be negative");
        }
        int oldCorePoolSize = executor.getCorePoolSize();
        executor.setCorePoolSize(newCorePoolSize);
        System.out.printf("Core pool size adjusted from %d to %d%n", 
            oldCorePoolSize, newCorePoolSize);
    }
    
    // 动态调整最大线程数
    public void adjustMaximumPoolSize(int newMaximumPoolSize) {
        if (newMaximumPoolSize < executor.getCorePoolSize()) {
            throw new IllegalArgumentException(
                "Maximum pool size cannot be smaller than core pool size");
        }
        int oldMaximumPoolSize = executor.getMaximumPoolSize();
        executor.setMaximumPoolSize(newMaximumPoolSize);
        System.out.printf("Maximum pool size adjusted from %d to %d%n", 
            oldMaximumPoolSize, newMaximumPoolSize);
    }
    
    // 提供性能监控指标
    public ThreadPoolMetrics getMetrics() {
        return new ThreadPoolMetrics(
            executor.getActiveCount(),
            executor.getPoolSize(),
            executor.getQueue().size(),
            totalTasks.get(),
            completedTasks.get()
        );
    }
    
    // 执行任务的方法
    public void execute(Runnable task) {
        totalTasks.incrementAndGet();
        executor.execute(() -> {
            try {
                task.run();
            } finally {
                completedTasks.incrementAndGet();
            }
        });
    }
}

// 线程池指标类
class ThreadPoolMetrics {
    private final int activeThreads;
    private final int poolSize;
    private final int queueSize;
    private final long totalTasks;
    private final long completedTasks;
    
    public ThreadPoolMetrics(int activeThreads, int poolSize, 
            int queueSize, long totalTasks, long completedTasks) {
        this.activeThreads = activeThreads;
        this.poolSize = poolSize;
        this.queueSize = queueSize;
        this.totalTasks = totalTasks;
        this.completedTasks = completedTasks;
    }
    
    // getter方法省略...
}

自适应调整策略

有了可以动态调整的线程池，我们还需要一个自适应的调整策略。下面是一个基于性能指标的自适应调整实现：

public class AdaptiveThreadPoolAdjuster {
    private final DynamicThreadPool threadPool;
    private final int minCorePoolSize;
    private final int maxCorePoolSize;
    private final double loadThresholdHigh = 0.75; // 负载高阈值
    private final double loadThresholdLow = 0.25;  // 负载低阈值
    
    public AdaptiveThreadPoolAdjuster(DynamicThreadPool threadPool, 
            int minCorePoolSize, int maxCorePoolSize) {
        this.threadPool = threadPool;
        this.minCorePoolSize = minCorePoolSize;
        this.maxCorePoolSize = maxCorePoolSize;
    }
    
    // 定期调整线程池大小
    public void startAdjustment(long period, TimeUnit unit) {
        ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
        scheduler.scheduleAtFixedRate(this::adjust, period, period, unit);
    }
    
    private void adjust() {
        ThreadPoolMetrics metrics = threadPool.getMetrics();
        int currentCorePoolSize = threadPool.executor.getCorePoolSize();
        
        // 计算负载情况
        double load = (double) metrics.getActiveThreads() / currentCorePoolSize;
        
        // 根据负载情况调整核心线程数
        if (load > loadThresholdHigh && currentCorePoolSize < maxCorePoolSize) {
            // 负载过高，增加线程数
            int newCorePoolSize = Math.min(currentCorePoolSize + 2, maxCorePoolSize);
            threadPool.adjustCorePoolSize(newCorePoolSize);
        } else if (load < loadThresholdLow && currentCorePoolSize > minCorePoolSize) {
            // 负载过低，减少线程数
            int newCorePoolSize = Math.max(currentCorePoolSize - 1, minCorePoolSize);
            threadPool.adjustCorePoolSize(newCorePoolSize);
        }
    }
}

使用示例

下面是一个具体的使用示例：


public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 创建动态线程池
        DynamicThreadPool threadPool = new DynamicThreadPool(
            4,  // 初始核心线程数
            10, // 最大线程数
            60L, 
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(100)
        );
        
        // 创建自适应调整器
        AdaptiveThreadPoolAdjuster adjuster = new AdaptiveThreadPoolAdjuster(
            threadPool, 
            2,  // 最小核心线程数
            8   // 最大核心线程数
        );
        
        // 启动自适应调整
        adjuster.startAdjustment(5, TimeUnit.SECONDS);
        
        // 模拟任务提交
        for (int i = 0; i < 1000; i++) {
            final int taskId = i;
            threadPool.execute(() -> {
                try {
                    // 模拟任务执行时间
                    Thread.sleep(new Random().nextInt(1000));
                    System.out.println("Task " + taskId + " completed");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
    }
}