说一下线程池的核心参数（线程池的执行原理知道吗）

线程池是一种多线程处理形式，它允许多个线程重用一组固定数量的线程，而不是为每个任务创建和销毁线程。使用线程池可以有效地管理资源，提高应用程序的响应速度和线程的利用率。

Java 中的线程池主要通过 java.util.concurrent.ExecutorService 接口及其实现类 ThreadPoolExecutor 来实现。ThreadPoolExecutor 是 Java 核心线程池的实现之一，它提供了许多配置选项来定制线程池的行为。以下是线程池的一些核心参数和执行原理：

线程池的核心参数

ThreadPoolExecutor 主要有以下核心参数：

1. corePoolSize：

   • 线程池的基本大小，在任何时候都至少会有这么多的线程存活，即使这些线程处于空闲状态。

2. maximumPoolSize：

   • 线程池能够容纳的最大线程数。如果任务太多，队列放不下，就会尝试创建新的线程，直到这个数目。

3. keepAliveTime：

   • 当线程数大于 corePoolSize 时，多余的空闲线程能够存活的时间。如果线程池中的线程数量超过 corePoolSize，且这些线程空闲时间超过 keepAliveTime，则会被终止。

4. unit：

   • keepAliveTime 参数的时间单位，如秒、毫秒等。

5. workQueue：

   • 任务队列（阻塞队列），用于存储等待执行的任务。当核心线程都在忙碌时，新任务会被放入这个队列中等待。它决定了线程池在何时以及如何拒绝任务。

6. threadFactory：

   • 用于创建新线程的工厂。可以通过这个工厂来设置线程的名称、优先级等属性。

7. handler：

   • 拒绝策略，当任务太多，任务队列放不下，且线程池中的线程数达到 maximumPoolSize 时，线程池会采取一定的策略处理新提交的任务。
     常见的饱和策略有：
     • ThreadPoolExecutor.AbortPolicy：抛出 RejectedExecutionException异常，阻止系统正常工作。
     • ThreadPoolExecutor.CallerRunsPolicy：调用者所在的线程执行任务。
     • ThreadPoolExecutor.DiscardPolicy：不做任务处理，默默地丢弃任务。
     • ThreadPoolExecutor.DiscardOldestPolicy：丢弃阻塞队列中等待最久的任务，然后尝试再次提交当前任务。

执行原理

线程池的执行流程如下：

1. 提交任务:

   • 当向线程池提交一个任务时，线程池会检查当前线程数是否小于 corePoolSize，如果是，则创建新的线程来执行任务。
   • 如果当前线程数等于或大于 corePoolSize，则会将任务放入任务队列中等待执行。

2. 任务队列溢出:

   • 如果任务队列已满，线程池会检查当前线程数是否小于 maximumPoolSize，如果是，则创建新的线程来执行任务。
   • 如果当前线程数等于 maximumPoolSize 且任务队列已满，线程池会根据拒绝策略来处理新提交的任务。

3. 任务执行:

   • 线程从任务队列中取出并执行任务，完成后任务被标记为已完成或从队列中移除。

4. 线程销毁：

   • 当线程空闲时间超过 keepAliveTime 时，且线程数大于 corePoolSize，线程池会逐渐销毁这些空闲线程，直到只剩下 corePoolSize 个线程。

5. 饱和策略：

   • 如果任务队列满了，且当前运行的线程等于 maximumPoolSize，线程池会根据配置的饱和策略来处理新任务。:

6. 线程复用：

   • 线程完成任务后，不会立即销毁，而是会再次循环利用，去执行队列中的下一个任务。

7. 关闭线程池:

   • 可以通过调用 shutdown() 方法来停止接收新任务，但是已经提交的任务会继续执行。
   • 调用 shutdownNow() 方法会立即尝试取消正在执行的任务，并停止处理队列中的任务。

通过合理配置这些参数，可以有效地控制线程池的行为，提高应用程序的性能和资源利用率。

示例代码

下面是一个简单的使用 ThreadPoolExecutor 创建线程池的例子：

import java.util.concurrent.*;

public class ThreadPoolExample {

    public static void main(String[] args) {
        int corePoolSize = 5;
        int maxPoolSize = 10;
        long keepAliveTime = 5000L; // 5 seconds
        TimeUnit unit = TimeUnit.MILLISECONDS;
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(100);
        ThreadFactory threadFactory = new DefaultThreadFactory("MyThreadPool");
        RejectedExecutionHandler handler = new ThreadPoolExecutor.CallerRunsPolicy();

        ExecutorService executor = new ThreadPoolExecutor(
                corePoolSize,
                maxPoolSize,
                keepAliveTime,
                unit,
                workQueue,
                threadFactory,
                handler);

        // 提交任务
        for (int i = 0; i < 15; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);
        }

        // 关闭线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
        }

        System.out.println("Finished all threads");
    }

    static class WorkerThread implements Runnable {

        private String command;

        public WorkerThread(String s) {
            this.command = s;
        }

        @Override
        public void run() {
            processCommand();
        }

        private void processCommand() {
            System.out.println(Thread.currentThread().getName() + " Start. Command = " + command);
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " End.");
        }

        @Override
        public String toString() {
            return this.command;
        }
    }

    static class DefaultThreadFactory implements ThreadFactory {
        private final String namePrefix;

        public DefaultThreadFactory(String namePrefix) {
            this.namePrefix = namePrefix;
        }

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, namePrefix + "-" + ThreadLocalRandom.current().nextInt());
            return t;
        }
    }
}