Java并发编程——线程池

一、使用线程池的好处

池化技术相比大家已经屡见不鲜了，线程池、数据库连接池、Http 连接池等等都是对这个思想的应用。池化技术的思想主要是为了减少每次获取资源的消耗，提高对资源的利用率。

线程池提供了一种限制和管理资源（包括执行一个任务）。每个线程池还维护一些基本统计信息，例如已完成任务的数量。

这里借用《Java 并发编程的艺术》提到的来说一下使用线程池的好处：

• 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
• 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
• 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

二、Executor 框架

2.1 简介

Executor 框架是 Java5 之后引进的，在 Java 5 之后，通过 Executor 来启动线程比使用 Thread 的 start 方法更好，除了更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免 this 逃逸问题。

补充：this 逃逸是指在构造函数返回之前其他线程就持有该对象的引用. 调用尚未构造完全的对象的方法可能引发令人疑惑的错误。

Executor 框架不仅包括了线程池的管理，还提供了线程工厂、队列以及拒绝策略等，Executor 框架让并发编程变得更加简单。

2.2 Executor 框架结构

1）任务 (Runnable / Callable)

任务表示需要被执行的工作，可以通过实现 Runnable 接口或 Callable 接口来定义。

• Runnable接口：没有返回值的方法 run()。
• Callable接口：有返回值的方法 call()，支持抛出异常。

这两个接口的实现类可以被 ThreadPoolExecutor 或 ScheduledThreadPoolExecutor 等执行。

2）任务的执行 (Executor)

任务的执行由 Executor 框架的核心接口组成，主要包括：

• Executor接口：核心接口，定义了 execute() 方法用于执行任务。
• ExecutorService接口：继承自 Executor 接口，提供了更多的任务管理功能，如任务的提交、取消等。
• ThreadPoolExecutor：实现了 ExecutorService 接口，提供了线程池的核心实现，控制线程池的工作线程数等参数。

ThreadPoolExecutor 类描述:

//AbstractExecutorService实现了ExecutorService接口
public class ThreadPoolExecutor extends AbstractExecutorService

• ScheduledThreadPoolExecutor：继承自 ThreadPoolExecutor 并实现了 ScheduledExecutorService，支持定时任务的调度。

ScheduledThreadPoolExecutor 类描述:

//ScheduledExecutorService继承ExecutorService接口
public class ScheduledThreadPoolExecutor
        extends ThreadPoolExecutor
        implements ScheduledExecutorService

这里提了很多底层的类关系，但是，实际上我们需要更多关注的是 ThreadPoolExecutor 这个类，这个类在我们实际使用线程池的过程中，使用频率还是非常高的。

类关系图如下：

3）异步计算的结果 (Future)

Future 接口及其实现类 FutureTask 表示任务的异步计算结果。

• Future接口：提供任务执行状态的查询、结果获取和任务取消等方法。
• FutureTask类：实现了 Future 和 Runnable 接口，允许将其作为任务提交给线程池执行。

submit() 方法返回一个实现 Future 接口的对象，通常是 FutureTask。通过 Future.get() 可以获取任务的执行结果，主线程可以等待任务完成；通过 Future.cancel() 可以取消任务的执行。

2.3 Executor 框架的使用示意图

1. 任务的创建：
主线程创建实现 Runnable 或 Callable 接口的任务对象。

2. 任务的提交：

• 将任务对象交给 ExecutorService 执行，使用 ExecutorService.execute(Runnable command) 或 ExecutorService.submit(Runnable task) 或 ExecutorService.submit(Callable<T> task) 方法。
• 如果使用 submit() 方法，会返回一个 Future 对象（如 FutureTask），表示异步计算的结果。

3. 任务结果的获取与管理：

• 主线程可以通过 Future.get() 等待任务执行完成并获取结果。
• 主线程也可以通过 Future.cancel(boolean mayInterruptIfRunning) 来取消任务的执行。

三、ThreadPoolExecutor 类

ThreadPoolExecutor 是 Executor 框架中最核心的类，提供了线程池的核心实现。它负责管理线程池中的线程，处理任务的执行以及控制资源的分配。

3.1 ThreadPoolExecutor 类分析

ThreadPoolExecutor 提供了四个构造方法，其中最长的一个构造方法提供了更多的灵活性。其他三个构造方法则是对一些参数提供了默认值。以下是 ThreadPoolExecutor最长的构造方法：

    /**
     * 用给定的初始参数创建一个新的ThreadPoolExecutor。
     */
    public ThreadPoolExecutor(int corePoolSize,//线程池的核心线程数量
                              int maximumPoolSize,//线程池的最大线程数
                              long keepAliveTime,//当线程数大于核心线程数时，多余的空闲线程存活的最长时间
                              TimeUnit unit,//时间单位
                              BlockingQueue<Runnable> workQueue,//任务队列，用来储存等待执行任务的队列
                              ThreadFactory threadFactory,//线程工厂，用来创建线程，一般默认即可
                              RejectedExecutionHandler handler//拒绝策略，当提交的任务过多而不能及时处理时，我们可以定制策略来处理任务
                               ) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

ThreadPoolExecutor 3 个最重要的参数：

• corePoolSize (核心线程数)：线程池中始终保持的最小线程数，即使线程池中的线程没有任务执行，它们也会保持活动状态。
• maximumPoolSize (最大线程数)：线程池中能够容纳的最大线程数。当任务队列已满且核心线程数已达到时，线程池将增加线程数，直到达到最大线程数。
• workQueue (任务队列)：用来缓存等待执行的任务。当线程池中的线程数达到核心线程数时，新任务会被放入此队列，等待有线程空闲时执行。

ThreadPoolExecutor其他常见参数:

• keepAliveTime (空闲线程的存活时间)：当线程池中的线程数大于corePoolSize时，如果线程空闲时间超过 keepAliveTime，它们将被销毁，直到线程数等于核心线程数。
• unit (时间单位)：keepAliveTime 的时间单位，使用 TimeUnit 来指定。
• threadFactory (线程工厂)：用来创建新线程的工厂，通常使用默认工厂即可。
• handler (饱和策略)：当线程池中的任务数量过多，超出线程池和任务队列的处理能力时，采用的饱和策略。常见的策略有：
  • ThreadPoolExecutor.AbortPolicy：抛出 RejectedExecutionException，拒绝新任务。
  • ThreadPoolExecutor.CallerRunsPolicy：调用执行自己的线程运行任务，也就是直接在调用execute方法的线程中运行(run)被拒绝的任务，如果执行程序已关闭，则会丢弃该任务。因此这种策略会降低对于新任务提交速度，影响程序的整体性能。如果您的应用程序可以承受此延迟并且你要求任何一个任务请求都要被执行的话，你可以选择这个策略。
  • ThreadPoolExecutor.DiscardPolicy：直接丢弃新任务。
  • ThreadPoolExecutor.DiscardOldestPolicy：丢弃任务队列中最早的任务。
    • 举个例子： Spring 通过 ThreadPoolTaskExecutor 或者我们直接通过 ThreadPoolExecutor 的构造函数创建线程池的时候，当我们不指定 RejectedExecutionHandler 饱和策略的话来配置线程池的时候默认使用的是 ThreadPoolExecutor.AbortPolicy。在默认情况下，ThreadPoolExecutor 将抛出 RejectedExecutionException 来拒绝新来的任务 ，这代表你将丢失对这个任务的处理。 对于可伸缩的应用程序，建议使用 ThreadPoolExecutor.CallerRunsPolicy。当最大池被填满时，此策略为我们提供可伸缩队列。（这个直接查看 ThreadPoolExecutor 的构造函数源码就可以看出，比较简单的原因，这里就不贴代码了。）

3.2 推荐使用 ThreadPoolExecutor 构造函数创建线程池

在《阿里巴巴 Java 开发手册》“并发处理”这一章节，明确指出线程资源必须通过线程池提供，不允许在应用中自行显示创建线程。

为什么呢？

使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源开销，解决资源不足的问题。如果不使用线程池，有可能会造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。

另外《阿里巴巴 Java 开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 构造函数的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

Executors 返回线程池对象的弊端如下：

• FixedThreadPool 和 SingleThreadExecutor ： 允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求，从而导致 OOM。
• CachedThreadPool 和 ScheduledThreadPool ： 允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致 OOM。

方式一：通过ThreadPoolExecutor构造函数实现（推荐）

方式二：通过 Executor 框架的工具类 Executors 来实现 我们可以创建三种类型的 ThreadPoolExecutor：

• FixedThreadPool
• SingleThreadExecutor
• CachedThreadPool

对应 Executors 工具类中的方法如图所示：

四、ThreadPoolExecutor 使用示例

我们上面讲解了 Executor框架以及 ThreadPoolExecutor 类，下面让我们实战一下，来通过写一个 ThreadPoolExecutor 的小 Demo 来回顾上面的内容。

4.1 示例代码:Runnable+ThreadPoolExecutor

首先创建一个 Runnable 接口的实现类（当然也可以是 Callable 接口，我们上面也说了两者的区别。）

import java.util.Date;

/**
 * 这是一个简单的Runnable类，需要大约5秒钟来执行其任务。
 */
public class MyRunnable implements Runnable {

    private String command;

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

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date());
        processCommand();
        System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date());
    }

    private void processCommand() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

编写测试程序，我们这里以阿里巴巴推荐的使用 ThreadPoolExecutor 构造函数自定义参数的方式来创建线程池。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorDemo {

    private static final int CORE_POOL_SIZE = 5;
    private static final int MAX_POOL_SIZE = 10;
    private static final int QUEUE_CAPACITY = 100;
    private static final Long KEEP_ALIVE_TIME = 1L;
    public static void main(String[] args) {

        //使用阿里巴巴推荐的创建线程池的方式
        //通过ThreadPoolExecutor构造函数自定义参数创建
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                KEEP_ALIVE_TIME,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                new ThreadPoolExecutor.CallerRunsPolicy());

        for (int i = 0; i < 10; i++) {
            //创建WorkerThread对象（WorkerThread类实现了Runnable 接口）
            Runnable worker = new MyRunnable("" + i);
            //执行Runnable
            executor.execute(worker);
        }
        //终止线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("Finished all threads");
    }
}

可以看到我们上面的代码指定了：

• corePoolSize: 核心线程数为 5。
• maximumPoolSize ：最大线程数 10
• keepAliveTime : 等待时间为 1L。
• unit: 等待时间的单位为 TimeUnit.SECONDS。
• workQueue：任务队列为 ArrayBlockingQueue，并且容量为 100;
• handler:饱和策略为 CallerRunsPolicy。

输出：

4.2 线程池原理分析

为了理解 ThreadPoolExecutor 的原理，我们需要深入分析线程池任务的提交与执行过程。通过 4.1 节的代码输出结果，我们可以看到，线程池首先会执行 5 个任务，然后在任务执行完成后会继续获取新任务来执行。接下来，我们分析 execute() 方法的源代码，从中揭示线程池是如何管理任务和线程的。

   // 存放线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)
   private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
   
    private static int workerCountOf(int c) {
        return c & CAPACITY;
    }
    //任务队列
    private final BlockingQueue<Runnable> workQueue;

    public void execute(Runnable command) {
        // 如果任务为null，则抛出异常。
        if (command == null)
            throw new NullPointerException();
        // ctl 中保存的线程池当前的一些状态信息
        int c = ctl.get();

        //  下面会涉及到 3 步 操作
        // 1.首先判断当前线程池中之行的任务数量是否小于 corePoolSize
        // 如果小于的话，通过addWorker(command, true)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        // 2.如果当前之行的任务数量大于等于 corePoolSize 的时候就会走到这里
        // 通过 isRunning 方法判断线程池状态，线程池处于 RUNNING 状态才会被并且队列可以加入任务，该任务才会被加入进去
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            // 再次获取线程池状态，如果线程池状态不是 RUNNING 状态就需要从任务队列中移除任务，并尝试判断线程是否全部执行完毕。同时执行拒绝策略。
            if (!isRunning(recheck) && remove(command))
                reject(command);
                // 如果当前线程池为空就新创建一个线程并执行。
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //3. 通过addWorker(command, false)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
        //如果addWorker(command, false)执行失败，则通过reject()执行相应的拒绝策略的内容。
        else if (!addWorker(command, false))
            reject(command);
    }

分析：
1. execute() 方法分析
execute(Runnable command) 方法是将任务提交到线程池执行的核心方法。我们通过该方法将任务提交给线程池，而线程池会根据任务的情况和线程池的状态，决定是否创建新线程、将任务放入队列等待执行，或者执行拒绝策略。
2. execute() 方法的3步逻辑

步骤 1：检查当前线程池中运行的线程数量

• 首先检查线程池中活跃线程的数量是否小于 corePoolSize，如果小于，则通过调用 addWorker(command, true) 创建新的工作线程来执行任务。
• 如果创建成功，任务会立即交给新线程执行。

if (workerCountOf(c) < corePoolSize) {
    if (addWorker(command, true))  // 创建核心线程
        return;
    c = ctl.get();  // 更新线程池的状态
}

步骤 2：判断等待队列是否已满

• 如果线程池中的线程数量已经达到核心线程数，且线程池处于 RUNNING 状态，线程池会尝试将任务放入 workQueue（任务队列）中等待执行。
• 如果任务队列成功放入任务，则会检查线程池的状态，如果状态发生变化（如不再是 RUNNING），则从队列中移除任务并执行饱和策略。如果线程池状态没有变化且没有空闲线程，则通过 addWorker(command, false) 创建新的工作线程。

if (isRunning(c) && workQueue.offer(command)) {
    int recheck = ctl.get();  // 重新检查线程池的状态
    if (!isRunning(recheck) && remove(command))  // 线程池不在 RUNNING 状态，移除任务
        reject(command);  // 执行拒绝策略
    else if (workerCountOf(recheck) == 0)  // 没有空闲线程，创建新的线程
        addWorker(null, false);
}

步骤 3：创建新线程

• 如果线程池中没有可用的线程来执行任务，并且任务队列也已经满了，则通过 addWorker(command, false) 创建新的工作线程执行任务。
• 如果创建新线程失败，则执行饱和策略。

通过下图可以更好的对上面这 3 步做一个展示

addWorker 这个方法主要用来创建新的工作线程，如果返回true说明创建和启动工作线程成功，否则的话返回的就是false。

    // 全局锁，并发操作必备
    private final ReentrantLock mainLock = new ReentrantLock();
    // 跟踪线程池的最大大小，只有在持有全局锁mainLock的前提下才能访问此集合
    private int largestPoolSize;
    // 工作线程集合，存放线程池中所有的（活跃的）工作线程，只有在持有全局锁mainLock的前提下才能访问此集合
    private final HashSet<Worker> workers = new HashSet<>();
    //获取线程池状态
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    //判断线程池的状态是否为 Running
    private static boolean isRunning(int c) {
        return c < SHUTDOWN;
    }


    /**
     * 添加新的工作线程到线程池
     * @param firstTask 要执行
     * @param core参数为true的话表示使用线程池的基本大小，为false使用线程池最大大小
     * @return 添加成功就返回true否则返回false
     */
   private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            //这两句用来获取线程池的状态
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
               //获取线程池中线程的数量
                int wc = workerCountOf(c);
                // core参数为true的话表明队列也满了，线程池大小变为 maximumPoolSize 
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
               //原子操作将workcount的数量加1
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                // 如果线程的状态改变了就再次执行上述操作
                c = ctl.get();  
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }
        // 标记工作线程是否启动成功
        boolean workerStarted = false;
        // 标记工作线程是否创建成功
        boolean workerAdded = false;
        Worker w = null;
        try {
        
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
              // 加锁
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                   //获取线程池状态
                    int rs = runStateOf(ctl.get());
                   //rs < SHUTDOWN 如果线程池状态依然为RUNNING,并且线程的状态是存活的话，就会将工作线程添加到工作线程集合中
                  //(rs=SHUTDOWN && firstTask == null)如果线程池状态小于STOP，也就是RUNNING或者SHUTDOWN状态下，同时传入的任务实例firstTask为null，则需要添加到工作线程集合和启动新的Worker
                   // firstTask == null证明只新建线程而不执行任务
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                       //更新当前工作线程的最大容量
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                      // 工作线程是否启动成功
                        workerAdded = true;
                    }
                } finally {
                    // 释放锁
                    mainLock.unlock();
                }
                //// 如果成功添加工作线程，则调用Worker内部的线程实例t的Thread#start()方法启动真实的线程实例
                if (workerAdded) {
                    t.start();
                  /// 标记线程启动成功
                    workerStarted = true;
                }
            }
        } finally {
           // 线程启动失败，需要从工作线程中移除对应的Worker
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

4.3 几个常见的对比

4.3.1 Runnable vs Callable

Runnable 接口自 Java 1.0 就已存在，而 Callable 接口是 Java 1.5 中引入的，主要目的是解决 Runnable 接口无法处理的一些用例。具体的区别如下：

Runnable 接口：

• 没有返回值：Runnable 的 run() 方法不会返回任何结果，无法获取任务执行的结果。
• 不能抛出检查异常：run() 方法无法抛出任何检查异常。

@FunctionalInterface
public interface Runnable {
    void run();  // 被线程执行，没有返回值也无法抛出异常
}

Callable 接口：

• 可以返回结果：Callable 接口的 call() 方法返回一个结果，这使得它能够返回任务的执行结果。
• 可以抛出检查异常：call() 方法允许抛出异常，这对处理可能出现的错误非常有用。

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;  // 计算结果，或抛出异常
}

转换：可以通过 Executors.callable(Runnable task) 或 Executors.callable(Runnable task, Object result) 将 Runnable 转换为 Callable，以便获取任务的返回结果。

4.3.2 execute() vs submit()

execute() 方法：用于提交一个不需要返回值的任务。任务执行后不会有返回结果，因此无法判断任务是否成功执行。

public void execute(Runnable command) {
    // 执行任务，但不会返回任何结果
}

submit() 方法：

• 用于提交一个需要返回值的任务。该方法会返回一个 Future 对象，通过 Future 对象可以判断任务是否执行成功。
• 通过 Future.get() 方法可以获取任务的返回值，get() 方法会阻塞当前线程直到任务完成。也可以通过 get(long timeout, TimeUnit unit) 方法设置超时时间。

public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<Void> ftask = newTaskFor(task, null);
    execute(ftask);
    return ftask;
}

newTaskFor() 方法返回一个 FutureTask 对象，FutureTask 实现了 Future 接口，因此可以通过 Future 对象获取任务执行结果。

protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
    return new FutureTask<T>(runnable, value);
}

4.3.3 shutdown() vs shutdownNow()

• shutdown()：关闭线程池，线程池的状态变为 SHUTDOWN。此时线程池不再接受新任务，但会继续执行队列中的任务，直到所有任务完成。
• shutdownNow()：关闭线程池，线程池的状态变为 STOP。此时线程池会终止当前正在运行的任务，并且会停止处理任务队列中的任务。同时，返回一个等待执行的任务列表。

4.3.4 isTerminated() vs isShutdown()

• isShutdown()：在调用 shutdown() 方法后，返回 true。表示线程池已经进入 SHUTDOWN 状态，但可能仍有任务正在执行或等待执行。
• isTerminated()：在调用 shutdown() 方法后，当所有提交的任务完成时返回 true，即所有任务都已经执行完毕。

4.4 Callable + ThreadPoolExecutor 示例代码

MyCallable.java

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(1000);
        // 返回执行当前 Callable 的线程名字
        return Thread.currentThread().getName();
    }
}

CallableDemo.java

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class CallableDemo {

    private static final int CORE_POOL_SIZE = 5;
    private static final int MAX_POOL_SIZE = 10;
    private static final int QUEUE_CAPACITY = 100;
    private static final Long KEEP_ALIVE_TIME = 1L;

    public static void main(String[] args) {

        // 使用阿里巴巴推荐的创建线程池的方式
        // 通过 ThreadPoolExecutor 构造函数自定义参数创建
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                KEEP_ALIVE_TIME,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                new ThreadPoolExecutor.CallerRunsPolicy());

        List<Future<String>> futureList = new ArrayList<>();
        Callable<String> callable = new MyCallable();
        for (int i = 0; i < 10; i++) {
            // 提交任务到线程池
            Future<String> future = executor.submit(callable);
            // 将返回值 future 添加到 list，我们可以通过 future 获得执行 Callable 得到的返回值
            futureList.add(future);
        }
        for (Future<String> fut : futureList) {
            try {
                System.out.println(new Date() + "::" + fut.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }
        // 关闭线程池
        executor.shutdown();
    }
}

输出示例：

在这个示例中，我们使用 ThreadPoolExecutor 来创建一个线程池，并使用 Callable 接口提交任务。每个任务会返回执行该任务的线程的名字。任务被提交到线程池后，线程池会分配线程来执行任务，并且通过 Future.get() 获取任务执行结果。

五、几种常见的线程池

5.1 FixedThreadPool

5.1.1 介绍

FixedThreadPool 是一个具有固定数量线程的线程池，通过 Executors 工具类可以创建该线程池。它是可重用的固定线程池，线程池中的线程数量始终保持在固定的值。

FixedThreadPool 的实现是通过 ThreadPoolExecutor 来完成的。可以通过以下两种方式创建：

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(), threadFactory);
}

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

从源代码中可以看出，FixedThreadPool 的 corePoolSize 和 maximumPoolSize 都被设置为 nThreads，这个值是用户传递的。LinkedBlockingQueue 是无界队列，用于存放待执行的任务。

5.1.2 执行任务过程介绍

FixedThreadPool 的 execute() 方法运行过程如下：

上图说明：

• 如果当前运行的线程数小于 corePoolSize，那么线程池会创建新的线程来执行任务。
• 当当前运行的线程数等于 corePoolSize 后，新提交的任务会被放入 LinkedBlockingQueue 等待。
• 线程池中的线程会反复从 LinkedBlockingQueue 中获取任务并执行。

5.1.3 为什么不推荐使用 FixedThreadPool？

FixedThreadPool 使用无界队列 LinkedBlockingQueue，它的容量为 Integer.MAX_VALUE，因此有以下问题：

• 当线程池中的线程数达到 corePoolSize 后，新任务将进入无界队列等待执行。
• 使用无界队列时，maximumPoolSize 会失效，因为任务队列不会满，线程池中的线程数不会超过 corePoolSize。
• keepAliveTime 也失效，因为无界队列的存在意味着线程池不会因为空闲线程超时而回收。
• 当任务量非常大时，可能导致内存溢出（OOM），因为队列无限增长，消耗过多内存。

因此，FixedThreadPool 不推荐用于高并发的任务场景。

5.2 SingleThreadExecutor

5.2.1 介绍

SingleThreadExecutor 是一个只有一个线程的线程池，保证任务按顺序执行。它的实现也是通过 ThreadPoolExecutor 来完成的。

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
    return new FinalizableDelegatedExecutorService(
        new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,
                               new LinkedBlockingQueue<Runnable>(), threadFactory));
}

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService(
        new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,
                               new LinkedBlockingQueue<Runnable>()));
}

SingleThreadExecutor 的 corePoolSize 和 maximumPoolSize 都被设置为 1，即线程池中始终只有一个线程在执行任务。

5.2.2 执行任务过程介绍

上图说明：

• 如果当前运行的线程数少于 corePoolSize，则创建一个新的线程执行任务；
• 当前线程池中有一个运行的线程后，后续的任务加入 LinkedBlockingQueue
• 线程执行完当前的任务后，会在循环中反复从LinkedBlockingQueue 中获取任务来执行；

5.2.3 为什么不推荐使用 SingleThreadExecutor？

SingleThreadExecutor 使用无界队列 LinkedBlockingQueue，同样存在以下问题：

• 队列无限制增长，如果任务量过大，可能导致内存溢出（OOM）。
• maximumPoolSize 和 keepAliveTime 参数失效，无法控制线程池的扩展和回收。
• 虽然保证了任务按顺序执行，但如果任务处理时间长，其他任务会被阻塞，影响性能。

因此，SingleThreadExecutor 适合用于任务顺序执行的场景，但不适用于高并发和大量任务的场景。

5.3 CachedThreadPool

5.3.1 介绍

CachedThreadPool 是一个根据需要创建线程的线程池，它会在之前创建的线程可用时进行复用。如果没有可用线程，它会创建新的线程来处理任务。

CachedThreadPool 的实现如下：

public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>(), threadFactory);
}

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

CachedThreadPool 的 corePoolSize 设置为 0，maximumPoolSize 设置为 Integer.MAX_VALUE，即线程池的线程数是无限制的，线程会根据需要创建，并且如果线程空闲超过 60 秒，会被回收。

5.3.2 执行任务过程介绍

CachedThreadPool 的任务执行过程如下：

上图说明：

• 首先执行 SynchronousQueue.offer(Runnable task) 提交任务到任务队列。如果当前 maximumPool 中有闲线程正在执行 SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)，那么主线程执行 offer 操作与空闲线程执行的 poll 操作配对成功，主线程把任务交给空闲线程执行，execute()方法执行完成，否则执行下面的步骤 2；
• 当初始 maximumPool 为空，或者 maximumPool 中没有空闲线程时，将没有线程执行 SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)。这种情况下，步骤 1 将失败，此时 CachedThreadPool 会创建新线程执行任务，execute 方法执行完成；

5.3.3 为什么不推荐使用 CachedThreadPool？

CachedThreadPool 允许线程池中创建大量线程（最大为 Integer.MAX_VALUE），如果任务量过大，会导致以下问题：

• 资源消耗过大：线程池没有上限，可能会创建大量线程，导致 CPU 和内存资源耗尽。
• 内存溢出（OOM）：由于线程池的大小不受限制，可能会导致大量线程被创建，进而消耗过多系统资源，最终导致 OOM。

因此，CachedThreadPool 不适用于任务量很大且无控制的情况，特别是在需要处理大量短时任务时，容易导致资源消耗过大。

六、ScheduledThreadPoolExecutor

ScheduledThreadPoolExecutor 主要用于在给定的延迟后运行任务，或者定期执行任务。虽然在实际项目中使用较少，通常会选择像 Quartz 这样的任务调度库，但了解 ScheduledThreadPoolExecutor 的工作原理仍然是很有用的，特别是在需要简单定时任务或周期性任务时。

6.1 简介

ScheduledThreadPoolExecutor 是继承自 ThreadPoolExecutor 的一个类，专门用于执行定时任务和周期性任务。

Timer 和 ScheduledThreadPoolExecutor 的比较：

• 对时钟变化的敏感度：
  • Timer 对系统时钟变化非常敏感。
  • ScheduledThreadPoolExecutor 对系统时钟的变化不敏感。
• 线程数量：
  • Timer 只有一个执行线程。
  • ScheduledThreadPoolExecutor 可以配置多个线程来执行任务。
• 异常处理：
  • 在 TimerTask 中，如果抛出运行时异常，则会导致整个 Timer 死机。
  • ScheduledThreadPoolExecutor 可以捕获异常，允许开发者处理它们，抛出异常的任务会被取消，但其他任务会继续执行。

综上所述，自 JDK 1.5 以来，ScheduledThreadPoolExecutor 是更推荐的任务调度方式，Timer 由于其局限性已经不再推荐使用。

备注： 在实际项目开发中，Quartz 是一个非常流行的任务调度框架。它不仅支持定时任务，还具有任务持久化、集群化等功能，因此在大规模任务调度中，Quartz 是一个更合适的选择。

6.2 运行机制

ScheduledThreadPoolExecutor 的运行机制主要分为以下两大部分：
1. 向 DelayQueue 添加任务：当调用 ScheduledThreadPoolExecutor 的 scheduleAtFixedRate() 或 scheduleWithFixedDelay() 方法时，线程池会将一个实现了 RunnableScheduledFuture 接口的 ScheduledFutureTask 放入 DelayQueue。
2. 线程池从 DelayQueue 获取任务并执行：线程池中的线程从 DelayQueue 中获取已经到期的 ScheduledFutureTask，并执行任务。

为了实现周期性任务调度，ScheduledThreadPoolExecutor 在 ThreadPoolExecutor 的基础上做了如下修改：

• 使用 DelayQueue 作为任务队列：DelayQueue 是一个支持延迟的队列，任务在指定的延迟时间后才会被取出执行。
• 获取任务的方式不同：ScheduledThreadPoolExecutor 从 DelayQueue 获取任务，而 ThreadPoolExecutor 直接从普通的队列中获取任务。
• 增加了周期任务的处理机制：在任务执行完毕后，会将任务重新放回队列，等待下次执行。

6.3 ScheduledThreadPoolExecutor 执行周期任务的步骤

ScheduledThreadPoolExecutor 执行周期性任务的过程可以分为以下几个步骤：

1. 线程获取已到期的任务：线程池中的线程（例如线程 1）从 DelayQueue 中获取已经到期的 ScheduledFutureTask。到期的任务是指 ScheduledFutureTask 中的 time（任务执行的预定时间）大于等于当前系统时间的任务。
2. 执行任务：线程 1 执行这个从 DelayQueue 中取出的 ScheduledFutureTask。这时，任务的 run()方法会被调用。
3. 重新设定任务的执行时间：执行完任务后，线程 1 会修改 ScheduledFutureTask 的 time 变量，将任务的下次执行时间设为下一个周期执行的时间。
4. 将任务放回 DelayQueue：修改了执行时间后的任务会被放回 DelayQueue，等待下次执行。下次执行时，线程 1 会再次获取这个任务并执行。

七、线程池大小确定

确定合适的线程池大小一直是多线程编程中的一个重要问题，许多程序员在设置线程池时往往是凭直觉决定，有时甚至觉得将线程池配置得更大一些就更好。实际上，线程池的大小需要根据具体的任务类型来合理调整，否则可能会出现一些不必要的性能问题。

一个常见的误区是，线程池配置过大可能不会带来性能提升，反而会增加系统的负担。我们可以用一个简单的现实生活例子来说明：并不是人多就能把事情做好。例如，当一项任务本来只需要3个人完成，如果硬要增加到6个人，反而可能因为沟通、协调等额外的成本，导致任务效率降低。

在多线程编程中，线程池大小过大会对性能产生类似影响，具体来说，增加了上下文切换的成本。接下来，我们将深入探讨这一点，并介绍如何根据任务类型来合理配置线程池的大小。

7.1 上下文切换

上下文切换（Context Switching） 是多线程编程中不可避免的开销。简单来说，当线程池中有多个线程同时在运行时，而 CPU 核心数量有限，CPU 需要通过上下文切换来切换不同线程的执行。上下文切换包括保存当前线程的状态，以及加载下一个线程的状态。

上下文切换的工作原理：

• 每个线程都有自己的状态（寄存器、程序计数器等信息），当线程的时间片用完时，操作系统将保存当前线程的状态，并切换到下一个线程。
• 线程切换的代价是时间和资源消耗。具体来说，它需要占用 CPU 的时间，通常是在纳秒级别。
• 上下文切换的消耗会增加系统的负担，尤其是在频繁发生时。多线程执行时，频繁的上下文切换可能导致 CPU 的时间被大量消耗在切换上下文上，影响任务的执行效率。
• 对于大量线程争用 CPU 资源的情况，过多的上下文切换会显著降低系统性能。因此，设置线程池大小时，必须避免线程数过多导致的上下文切换开销。

7.2 线程池大小的合理设置

为了避免线程池配置过大或过小导致的性能问题，我们需要根据任务的类型来设定合理的线程池大小。任务类型大致分为两类：CPU 密集型任务和I/O 密集型任务。

7.2.1 CPU 密集型任务

CPU 密集型任务是那些大量使用 CPU 进行计算的任务，例如进行复杂的数学计算、排序、图像处理等。通常，CPU 密集型任务的执行时间大多消耗在 CPU 上，而与 I/O 操作无关。

在这种情况下，线程池的大小应该与 CPU 核心数密切相关。过多的线程会增加上下文切换，导致性能下降，因此线程池的大小应该尽量保持在 CPU 核心数附近。

推荐的线程池大小：对于 CPU 密集型任务，线程池的大小一般可以设置为 N + 1，其中 N 是 CPU 核心数。额外增加的一个线程是为了应对偶发的缺页中断或其他原因导致的任务暂停，防止 CPU 在等待任务时空闲。

公式：线程池大小 = N + 1（N 为 CPU 核心数）

为什么增加一个线程？ 由于在执行 CPU 密集型任务时，可能会有任务暂停（例如，线程可能会进行内存读取操作或其他原因导致暂停）。此时，增加一个线程可以充分利用 CPU 的空闲时间，确保线程池中的任务能够持续执行。

7.2.2 I/O 密集型任务

I/O 密集型任务是那些主要消耗 I/O 资源（例如网络请求、磁盘读取等）的任务，而这些任务在执行过程中大部分时间会处于等待状态。当线程在等待 I/O 操作完成时，它不会占用 CPU 资源。

因此，在 I/O 密集型任务中，CPU 可以在等待 I/O 的过程中被其他线程使用，从而提高 CPU 的利用率。因此，相比于 CPU 密集型任务，I/O 密集型任务可以使用更多的线程。

推荐的线程池大小：对于 I/O 密集型任务，线程池的大小一般可以设置为 2 * N，其中 N 是 CPU 核心数。增加的线程数是为了充分利用 CPU 在等待 I/O 操作完成时的空闲时间。

公式：线程池大小 = 2 * N（N 为 CPU 核心数）

为什么是 2 倍？ 由于 I/O 密集型任务在等待 I/O 操作时不会占用 CPU 资源，所以可以配置更多的线程来处理其他任务。通过设置更大的线程池，能够更好地利用 CPU 空闲时间，提高并发处理能力。

7.3 如何判断是 CPU 密集型任务还是 I/O 密集型任务？

要确定是 CPU 密集型任务还是 I/O 密集型任务，通常可以通过以下特征进行区分：

CPU 密集型任务：

• 主要消耗 CPU 的计算能力，例如进行复杂计算、大量数据排序、图像处理等。
• 任务的执行时间大部分由 CPU 时间构成。

I/O 密集型任务：

• 主要消耗 I/O 资源，如网络请求、数据库访问、文件读写等。
• 任务的执行时间大部分由等待 I/O 操作完成所构成，CPU 时间相对较少。

简单来说，CPU 密集型任务是在进行大量的计算，而 I/O 密集型任务则是在等待数据的传输和处理。例如：

• 对于需要大量计算的任务（如排序、加密、解密、机器学习计算等），它是 CPU 密集型任务。
• 对于读取文件、访问数据库、进行网络请求等任务，它则是 I/O 密集型任务。