面试题： Java 线程池核心线程数在运行过程中能修改吗？如何修改？

在 Java 的标准线程池实现中，核心线程数（corePoolSize）在运行过程中是不能直接修改的。ThreadPoolExecutor 的核心线程数是通过构造函数设置的，并且在运行过程中没有提供直接修改它的方法。

不过，可以通过一些间接的方式来实现动态调整核心线程数。以下是几种常见的方法：

1. 使用 `setCorePoolSize()` 方法

ThreadPoolExecutor 提供了一个 setCorePoolSize(int corePoolSize) 方法，可以在运行时动态调整核心线程数。

方法行为：

如果新的核心线程数大于当前核心线程数，线程池会创建新的线程。
如果新的核心线程数小于当前核心线程数，多余的线程会在空闲时被回收。

示例：

import java.util.concurrent.*;

public class DynamicCorePoolSize {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                2, // 初始核心线程数
                4, // 最大线程数
                60, TimeUnit.SECONDS, // 空闲线程存活时间
                new LinkedBlockingQueue<>() // 任务队列
        );

        // 提交任务
        for (int i = 0; i < 6; i++) {
            executor.execute(() -> {
                try {
                    Thread.sleep(1000);
                    System.out.println("任务执行线程: " + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        // 动态调整核心线程数
        executor.setCorePoolSize(4);
        System.out.println("核心线程数已调整为: " + executor.getCorePoolSize());

        executor.shutdown();
    }
}

输出：

核心线程数已调整为: 4
任务执行线程: pool-1-thread-1
任务执行线程: pool-1-thread-2
任务执行线程: pool-1-thread-3
任务执行线程: pool-1-thread-4

2. 自定义线程池

如果需要更灵活的控制，可以继承 ThreadPoolExecutor 并重写相关方法，实现自定义的核心线程数调整逻辑。

示例：

import java.util.concurrent.*;

public class CustomThreadPool extends ThreadPoolExecutor {
    public CustomThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    @Override
    public void setCorePoolSize(int corePoolSize) {
        super.setCorePoolSize(corePoolSize);
        System.out.println("核心线程数已动态调整为: " + corePoolSize);
    }

    public static void main(String[] args) {
        CustomThreadPool executor = new CustomThreadPool(2, 4, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>());

        // 提交任务
        for (int i = 0; i < 6; i++) {
            executor.execute(() -> {
                try {
                    Thread.sleep(1000);
                    System.out.println("任务执行线程: " + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        // 动态调整核心线程数
        executor.setCorePoolSize(4);

        executor.shutdown();
    }
}

3. 使用 `Executors.newCachedThreadPool()`

newCachedThreadPool() 创建的线程池没有固定的核心线程数，线程数会根据任务数量动态调整。虽然这不是直接修改核心线程数，但可以达到类似的效果。

示例：

import java.util.concurrent.*;

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();

        // 提交任务
        for (int i = 0; i < 10; i++) {
            executor.execute(() -> {
                try {
                    Thread.sleep(1000);
                    System.out.println("任务执行线程: " + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
    }
}