嘿，这个需求完全可行，咱们来一步步拆解你的问题：

1. 是否可实现？ #

当然可以！Java的ThreadPoolExecutor本身就提供了动态调整线程池大小的API，你可以在运行时修改核心线程数和最大线程数，而且你的代码里已经用静态变量维护了唯一的线程池实例，天然满足“每次Parent执行复用同一个线程池”的要求。

2. 是否推荐这么做？ #

要分场景来看：

• 推荐的场景：如果你的系统需要应对波动的负载（比如某些时段任务突增，空闲时段任务减少），动态调整线程池大小可以更高效地利用系统资源，避免资源浪费或任务堆积。
• 需要谨慎的点：
  • 频繁调整线程池大小会带来线程创建/销毁的开销，反而降低性能；
  • 调整后的大小如果不合理（比如设置过大导致CPU/内存耗尽，或者过小导致任务排队超时），会引发新的问题；
  • 建议结合系统监控数据（比如CPU使用率、任务队列长度、线程活跃度）来做有依据的动态调整，而不是盲目修改。

3. 具体实现方案 #

基于你提供的代码，我帮你做针对性的修改，核心是利用ThreadPoolExecutor的setCorePoolSize()和setMaximumPoolSize()方法，同时修正一些小问题：

修正后的完整代码 #

ThreadPoolTest.java

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPoolTest {
    public static void main(String[] args) {
        Parent parent = new Parent();
        try {
            ScheduledExecutorService executor_instant = Executors.newSingleThreadScheduledExecutor();
            // 注意：直接调度Runnable实例即可，不需要包装成Thread
            executor_instant.scheduleAtFixedRate(parent, 0, 10, TimeUnit.SECONDS);
            
            // 示例：运行5秒后将线程池大小调整为80
            Thread.sleep(5000);
            Parent.setThreadPoolSize(80);
            System.out.println("线程池大小已调整为80");
            
            // 再运行10秒后调整回30
            Thread.sleep(10000);
            Parent.setThreadPoolSize(30);
            System.out.println("线程池大小已调整为30");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Parent.java

import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.LinkedBlockingQueue;

public class Parent implements Runnable {
    private static ThreadPoolExecutor executor;
    private static int threadPoolSize = 50;

    static {
        // 直接初始化ThreadPoolExecutor，比Executors.newFixedThreadPool更灵活
        executor = new ThreadPoolExecutor(
                threadPoolSize,
                threadPoolSize,
                0L,
                java.util.concurrent.TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<>()
        );
    }

    @Override
    public void run() {
        System.out.println("Parent线程执行，当前线程池核心大小：" + executor.getCorePoolSize());
        for (int i = 0; i < 100; i++) {
            Child child = new Child();
            executor.execute(child);
        }
    }

    // 提供静态方法用于动态修改线程池大小
    public static void setThreadPoolSize(int newSize) {
        if (newSize <= 0) {
            throw new IllegalArgumentException("线程池大小不能小于等于0");
        }
        // 同时设置核心线程数和最大线程数，保持一致（如果需要伸缩性可以分开设置）
        executor.setCorePoolSize(newSize);
        executor.setMaximumPoolSize(newSize);
        threadPoolSize = newSize;
    }
}

Child.java

public class Child implements Runnable {
    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        System.out.println("Child线程[" + threadName + "]开始执行");
        for (int i = 0; i < 3; i++) {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                System.out.println("Child线程[" + threadName + "]被中断");
                Thread.currentThread().interrupt(); // 保留中断状态
                return;
            }
        }
        System.out.println("Child线程[" + threadName + "]执行完成");
    }
}

关键实现说明 #

1. 线程池复用：通过static变量executor保证整个应用中只有一个线程池实例，每次Parent的run()方法都会复用它提交Child任务。
2. 动态调整大小：setThreadPoolSize()方法调用ThreadPoolExecutor的setCorePoolSize()和setMaximumPoolSize()，实现运行时修改。如果需要让线程池具备伸缩能力（比如核心线程数固定，最大线程数动态调整），可以单独修改setMaximumPoolSize()，同时设置合理的keepAliveTime（比如把初始的0L改成60L，让空闲的非核心线程存活60秒）。
3. 调度修正：原来的代码把Thread实例传给scheduleAtFixedRate()，这是错误的——ScheduledExecutorService会调用Thread的run()方法（而不是start()），相当于直接执行Runnable逻辑，不会启动新线程。现在直接传Parent实例才是正确的用法。

额外注意事项 #

• 如果要做自动化的动态调整，可以结合系统指标：比如监控线程池的getQueue().size()（队列长度）、getActiveCount()（活跃线程数），当队列积压超过阈值时增大线程池，当空闲线程过多时缩小。
• 避免在线程池已经shutdown()或terminated()后修改大小，否则会抛出IllegalStateException，可以在setThreadPoolSize()里先判断executor.isShutdown()。

内容的提问来源于stack exchange，提问作者Tushar Thakur