关键词：

本文你将获得以下信息：

• 线程池源码解读
• 线程池执行流程分析
• 带返回值的线程池实现
• 延迟线程池实现

为了方便读者理解，本文会由浅入深，先从线程池的使用开始再延伸到源码解读和源码分析等高级内容，读者可根据自己的情况自主选择阅读顺序和需要了解的章节。

一、线程池优点

线程池能够更加充分的利用CPU、内存、网络、IO等系统资源，线程池的主要作用如下：

• 利用线程池可以复用线程，控制最大并发数；
• 实现任务缓存策略和拒绝机制；
• 实现延迟执行

阿里巴巴Java开发手册强制规定：线程资源必须通过线程池提供，如下图：

二、线程池使用

本节会介绍7种线程池的创建与使用，线程池的状态介绍，ThreadPoolExecutor参数介绍等。

2.1 线程池创建

线程池可以使用Executors和ThreadPoolExecutor，其中使用Executors有六种创建线程池的方法，如下图：

// 使用Executors方式创建
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2);
ScheduledExecutorService singleThreadScheduledExecutor = Executors.newSingleThreadScheduledExecutor();
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);
ExecutorService workStealingPool = Executors.newWorkStealingPool();
// 原始创建方式
ThreadPoolExecutor tp = new ThreadPoolExecutor(10, 10, 10L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());

2.1.1 线程池解读

1. newSingleThreadExecutor()，它的特点在于工作线程数目被限制为 1，操作一个×××的工作队列，所以它保证了所有任务的都是被顺序执行，最多会有一个任务处于活动状态，并且不允许使用者改动线程池实例，因此可以避免其改变线程数目。
2. newCachedThreadPool()，它是一种用来处理大量短时间工作任务的线程池，具有几个鲜明特点：它会试图缓存线程并重用，当无缓存线程可用时，就会创建新的工作线程；如果线程闲置的时间超过 60 秒，则被终止并移出缓存；长时间闲置时，这种线程池，不会消耗什么资源。其内部使用 SynchronousQueue 作为工作队列。
3. newFixedThreadPool(int nThreads)，重用指定数目（nThreads）的线程，其背后使用的是×××的工作队列，任何时候最多有 nThreads 个工作线程是活动的。这意味着，如果任务数量超过了活动队列数目，将在工作队列中等待空闲线程出现；如果有工作线程退出，将会有新的工作线程被创建，以补足指定的数目 nThreads。
4. newSingleThreadScheduledExecutor() 创建单线程池，返回 ScheduledExecutorService，可以进行定时或周期性的工作调度。
5. newScheduledThreadPool(int corePoolSize)和newSingleThreadScheduledExecutor()类似，创建的是个 ScheduledExecutorService，可以进行定时或周期性的工作调度，区别在于单一工作线程还是多个工作线程。
6. newWorkStealingPool(int parallelism)，这是一个经常被人忽略的线程池，Java 8 才加入这个创建方法，其内部会构建<a href="https://docs.oracle.com/javase/9/docs/api/java/util/concurrent/ForkJoinPool.html">ForkJoinPool</a>，利用<a href="https://en.wikipedia.org/wiki/Work_stealing">Work-Stealing</a>算法，并行地处理任务，不保证处理顺序。
7. ThreadPoolExecutor是最原始的线程池创建，上面1-3创建方式都是对ThreadPoolExecutor的封装。

总结： 其中newSingleThreadExecutor、newCachedThreadPool、newFixedThreadPool是对ThreadPoolExecutor的封装实现，newSingleThreadScheduledExecutor、newScheduledThreadPool则为ThreadPoolExecutor子类ScheduledThreadPoolExecutor的封装，用于执行延迟任务，newWorkStealingPool则为Java 8新加的方法。

2.1.2 单线程池的意义

从以上代码可以看出newSingleThreadExecutor和newSingleThreadScheduledExecutor创建的都是单线程池，那么单线程池的意义是什么呢？

虽然是单线程池，但提供了工作队列，生命周期管理，工作线程维护等功能。

2.2 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.acc = System.getSecurityManager() == null ?
            null :
            AccessController.getContext();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

参数说明：

• corePoolSize：所谓的核心线程数，可以大致理解为长期驻留的线程数目（除非设置了 allowCoreThreadTimeOut）。对于不同的线程池，这个值可能会有很大区别，比如 newFixedThreadPool 会将其设置为 nThreads，而对于 newCachedThreadPool 则是为 0。
• maximumPoolSize：顾名思义，就是线程不够时能够创建的最大线程数。同样进行对比，对于 newFixedThreadPool，当然就是 nThreads，因为其要求是固定大小，而 newCachedThreadPool 则是 Integer.MAX_VALUE。
• keepAliveTime：空闲线程的保活时间，如果线程的空闲时间超过这个值，那么将会被关闭。注意此值生效条件必须满足：空闲时间超过这个值，并且线程池中的线程数少于等于核心线程数corePoolSize。当然核心线程默认是不会关闭的，除非设置了allowCoreThreadTimeOut(true)那么核心线程也可以被回收。
• TimeUnit：时间单位。
• BlockingQueue：任务丢列，用于存储线程池的待执行任务的。
• threadFactory：用于生成线程，一般我们可以用默认的就可以了。
• handler：当线程池已经满了，但是又有新的任务提交的时候，该采取什么策略由这个来指定。有几种方式可供选择，像抛出异常、直接拒绝然后返回等，也可以自己实现相应的接口实现自己的逻辑。

---

来看一下线程池封装类对于ThreadPoolExecutor的调用：

newSingleThreadExecutor对ThreadPoolExecutor的封装源码如下：

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

newCachedThreadPool对ThreadPoolExecutor的封装源码如下：

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

newFixedThreadPool对ThreadPoolExecutor的封装源码如下：

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

ScheduledExecutorService对ThreadPoolExecutor的封装源码如下：

public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
    return new DelegatedScheduledExecutorService
        (new ScheduledThreadPoolExecutor(1));
}

newSingleThreadScheduledExecutor使用的是ThreadPoolExecutor的子类ScheduledThreadPoolExecutor，如下图所示：

newScheduledThreadPool对ThreadPoolExecutor的封装源码如下：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}

newScheduledThreadPool使用的也是ThreadPoolExecutor的子类ScheduledThreadPoolExecutor。

2.3 线程池状态

查看ThreadPoolExecutor源码可知线程的状态如下：

线程状态解读（以下内容来源于：https://javadoop.com/post/java-thread-pool）：

• RUNNING：这个没什么好说的，这是最正常的状态：接受新的任务，处理等待队列中的任务；
• SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务；
• STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程；
• TIDYING：所有的任务都销毁了，workCount 为 0。线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()；
• TERMINATED：terminated() 方法结束后，线程池的状态就会变成这个；

RUNNING 定义为 -1，SHUTDOWN 定义为 0，其他的都比 0 大，所以等于 0 的时候不能提交任务，大于 0 的话，连正在执行的任务也需要中断。

看了这几种状态的介绍，读者大体也可以猜到十之八九的状态转换了，各个状态的转换过程有以下几种：

• RUNNING -> SHUTDOWN：当调用了 shutdown() 后，会发生这个状态转换，这也是最重要的；
• (RUNNING or SHUTDOWN) -> STOP：当调用 shutdownNow() 后，会发生这个状态转换，这下要清楚 shutDown() 和 shutDownNow() 的区别了；
• SHUTDOWN -> TIDYING：当任务队列和线程池都清空后，会由 SHUTDOWN 转换为 TIDYING；
• STOP -> TIDYING：当任务队列清空后，发生这个转换；
• TIDYING -> TERMINATED：这个前面说了，当 terminated() 方法结束后；

2.4 线程池执行

说了那么多下来一起来看线程池的是怎么执行任务的，线程池任务提交有两个方法：

• execute
• submit

其中execute只能接受Runnable类型的任务，使用如下：

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
singleThreadExecutor.execute(new Runnable() {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
});

submit可以接受Runnable或Callable类型的任务，使用如下：

ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.submit(new Runnable() {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
});

2.4.1 带返回值的线程池实现

使用submit传递Callable类可以获取执行任务的返回值，Callable是JDK 1.5 添加的特性用于补充Runnable无返回的情况。

ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<Long> result = executorService.submit(new Callable<Long>() {
    @Override
    public Long call() throws Exception {
        return new Date().getTime();
    }
});
try {
    System.out.println("运行结果：" + result.get());
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    e.printStackTrace();
}

2.4.2 延迟线程池实现

在线程池中newSingleThreadScheduledExecutor和newScheduledThreadPool返回的是ScheduledExecutorService，用于执行延迟线程池的，代码如下：

// 延迟线程池
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);
scheduledThreadPool.schedule(new Runnable() {
    @Override
    public void run() {
        System.out.println("time:" + new Date().getTime());
    }
}, 10, TimeUnit.SECONDS);

完整示例下载地址： https://github.com/vipstone/java-core-example

三、线程池源码解读

阅读线程池的源码有一个小技巧，可以按照线程池执行的顺序进行串连关联阅读，这样更容易理解线程池的实现。

源码阅读流程解读

我们先从线程池的任务提交方法execute()开始阅读，从execute()我们会发现线程池执行的核心方法是addWorker()，在addWorker()中我们发现启动线程调用了start()方法，调用start()方法之后会执行Worker类的run()方法，run里面调用runWorker()，运行程序的关键在于getTask()方法，getTask()方法之后就是此线程的关闭，整个线程池的工作流程也就完成了，下来一起来看吧（如果本段文章没看懂的话也可以看完源码之后，回过头来再看一遍）。

3.1 execute() 源码解读

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    int c = ctl.get();

    // 如果当前线程数少于核心线程数，那么直接添加一个 worker 来执行任务，
    // 创建一个新的线程，并把当前任务 command 作为这个线程的第一个任务(firstTask)
    if (workerCountOf(c) < corePoolSize) {
        // 添加任务成功，那么就结束了。提交任务嘛，线程池已经接受了这个任务，这个方法也就可以返回了
        // 至于执行的结果，到时候会包装到 FutureTask 中。
        // 返回 false 代表线程池不允许提交任务
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 到这里说明，要么当前线程数大于等于核心线程数，要么刚刚 addWorker 失败了

    // 如果线程池处于 RUNNING 状态，把这个任务添加到任务队列 workQueue 中
    if (isRunning(c) && workQueue.offer(command)) {
        /* 这里面说的是，如果任务进入了 workQueue，我们是否需要开启新的线程
         * 因为线程数在 [0, corePoolSize) 是无条件开启新的线程
         * 如果线程数已经大于等于 corePoolSize，那么将任务添加到队列中，然后进到这里
         */
        int recheck = ctl.get();
        // 如果线程池已不处于 RUNNING 状态，那么移除已经入队的这个任务，并且执行拒绝策略
        if (! isRunning(recheck) && remove(command))
            reject(command);
        // 如果线程池还是 RUNNING 的，并且线程数为 0，那么开启新的线程
        // 到这里，我们知道了，这块代码的真正意图是：担心任务提交到队列中了，但是线程都关闭了
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 如果 workQueue 队列满了，那么进入到这个分支
    // 以 maximumPoolSize 为界创建新的 worker，
    // 如果失败，说明当前线程数已经达到 maximumPoolSize，执行拒绝策略
    else if (!addWorker(command, false))
        reject(command);
}

3.2 addWorker() 源码解读

// 第一个参数是准备提交给这个线程执行的任务，之前说了，可以为 null
// 第二个参数为 true 代表使用核心线程数 corePoolSize 作为创建线程的界线，也就说创建这个线程的时候，
//         如果线程池中的线程总数已经达到 corePoolSize，那么不能响应这次创建线程的请求
//         如果是 false，代表使用最大线程数 maximumPoolSize 作为界线
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // 这个非常不好理解
        // 如果线程池已关闭，并满足以下条件之一，那么不创建新的 worker：
        // 1. 线程池状态大于 SHUTDOWN，其实也就是 STOP, TIDYING, 或 TERMINATED
        // 2. firstTask != null
        // 3. workQueue.isEmpty()
        // 简单分析下：
        // 还是状态控制的问题，当线程池处于 SHUTDOWN 的时候，不允许提交任务，但是已有的任务继续执行
        // 当状态大于 SHUTDOWN 时，不允许提交任务，且中断正在执行的任务
        // 多说一句：如果线程池处于 SHUTDOWN，但是 firstTask 为 null，且 workQueue 非空，那么是允许创建 worker 的
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;

        for (;;) {
            int wc = workerCountOf(c);
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            // 如果成功，那么就是所有创建线程前的条件校验都满足了，准备创建线程执行任务了
            // 这里失败的话，说明有其他线程也在尝试往线程池中创建线程
            if (compareAndIncrementWorkerCount(c))
                break retry;
            // 由于有并发，重新再读取一下 ctl
            c = ctl.get();
            // 正常如果是 CAS 失败的话，进到下一个里层的for循环就可以了
            // 可是如果是因为其他线程的操作，导致线程池的状态发生了变更，如有其他线程关闭了这个线程池
            // 那么需要回到外层的for循环
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }

    /* 
     * 到这里，我们认为在当前这个时刻，可以开始创建线程来执行任务了，
     * 因为该校验的都校验了，至于以后会发生什么，那是以后的事，至少当前是满足条件的
     */

    // worker 是否已经启动
    boolean workerStarted = false;
    // 是否已将这个 worker 添加到 workers 这个 HashSet 中
    boolean workerAdded = false;
    Worker w = null;
    try {
        final ReentrantLock mainLock = this.mainLock;
        // 把 firstTask 传给 worker 的构造方法
        w = new Worker(firstTask);
        // 取 worker 中的线程对象，之前说了，Worker的构造方法会调用 ThreadFactory 来创建一个新的线程
        final Thread t = w.thread;
        if (t != null) {
            // 这个是整个类的全局锁，持有这个锁才能让下面的操作“顺理成章”，
            // 因为关闭一个线程池需要这个锁，至少我持有锁的期间，线程池不会被关闭
            mainLock.lock();
            try {

                int c = ctl.get();
                int rs = runStateOf(c);

                // 小于 SHUTTDOWN 那就是 RUNNING，这个自不必说，是最正常的情况
                // 如果等于 SHUTDOWN，前面说了，不接受新的任务，但是会继续执行等待队列中的任务
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    // worker 里面的 thread 可不能是已经启动的
                    if (t.isAlive())
                        throw new IllegalThreadStateException();
                    // 加到 workers 这个 HashSet 中
                    workers.add(w);
                    int s = workers.size();
                    // largestPoolSize 用于记录 workers 中的个数的最大值
                    // 因为 workers 是不断增加减少的，通过这个值可以知道线程池的大小曾经达到的最大值
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            // 添加成功的话，启动这个线程
            if (workerAdded) {
                // 启动线程
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        // 如果线程没有启动，需要做一些清理工作，如前面 workCount 加了 1，将其减掉
        if (! workerStarted)
            addWorkerFailed(w);
    }
    // 返回线程是否启动成功
    return workerStarted;
}

在这段代码可以看出，调用了t.start();

3.3 runWorker() 源码解读

根据上面代码可知，调用了Worker的t.start()之后，紧接着会调用Worker的run()方法，run()源码如下：

public void run() {
    runWorker(this);
}

runWorker()源码如下：

//  worker 线程启动后调用,while 循环(即自旋!)不断从等待队列获取任务并执行
//  worker 初始化时，可指定 firstTask，那么第一个任务也就可以不需要从队列中获取
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    // 该线程的第一个任务(若有)
    Runnable task = w.firstTask;
    w.firstTask = null;
    // 允许中断
    w.unlock(); 
    boolean completedAbruptly = true;
    try {
        // 循环调用 getTask 获取任务
        while (task != null || (task = getTask()) != null) {
            w.lock();          
            // 若线程池状态大于等于 STOP，那么意味着该线程也要中断
              /**
               * 若线程池STOP，请确保线程 已被中断
               * 如果没有，请确保线程未被中断
               * 这需要在第二种情况下进行重新检查，以便在关中断时处理shutdownNow竞争
               */
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                // 这是一个钩子方法，留给需要的子类实现
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    // 到这里终于可以执行任务了
                    task.run();
                } catch (RuntimeException x) {
                    thrown = x; throw x;
                } catch (Error x) {
                    thrown = x; throw x;
                } catch (Throwable x) {
                    // 这里不允许抛出 Throwable，所以转换为 Error
                    thrown = x; throw new Error(x);
                } finally {
                    // 也是一个钩子方法，将 task 和异常作为参数，留给需要的子类实现
                    afterExecute(task, thrown);
                }
            } finally {
                // 置空 task，准备 getTask 下一个任务
                task = null;
                // 累加完成的任务数
                w.completedTasks++;
                // 释放掉 worker 的独占锁
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        // 到这里，需要执行线程关闭
        // 1. 说明 getTask 返回 null，也就是说，这个 worker 的使命结束了，执行关闭
        // 2. 任务执行过程中发生了异常
        //    第一种情况，已经在代码处理了将 workCount 减 1，这个在 getTask 方法分析中说
        //    第二种情况，workCount 没有进行处理，所以需要在 processWorkerExit 中处理
        processWorkerExit(w, completedAbruptly);
    }
}

3.4 getTask() 源码解读

runWorker里面的有getTask()，来看下具体的实现：

// 此方法有三种可能
// 1. 阻塞直到获取到任务返回。默认 corePoolSize 之内的线程是不会被回收的，它们会一直等待任务
// 2. 超时退出。keepAliveTime 起作用的时候，也就是如果这么多时间内都没有任务，那么应该执行关闭
// 3. 如果发生了以下条件，须返回 null
//     池中有大于 maximumPoolSize 个 workers 存在(通过调用 setMaximumPoolSize 进行设置)
//     线程池处于 SHUTDOWN，而且 workQueue 是空的，前面说了，这种不再接受新的任务
//     线程池处于 STOP，不仅不接受新的线程，连 workQueue 中的线程也不再执行
private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?
   for (;;) {
            // 允许核心线程数内的线程回收，或当前线程数超过了核心线程数，那么有可能发生超时关闭
            // 这里 break，是为了不往下执行后一个 if (compareAndDecrementWorkerCount(c))
            // 两个 if 一起看：如果当前线程数 wc > maximumPoolSize，或者超时，都返回 null
            // 那这里的问题来了，wc > maximumPoolSize 的情况，为什么要返回 null？
            // 换句话说，返回 null 意味着关闭线程。
            // 那是因为有可能开发者调用了 setMaximumPoolSize 将线程池的 maximumPoolSize 调小了
            // 如果此 worker 发生了中断，采取的方案是重试
            // 解释下为什么会发生中断，这个读者要去看 setMaximumPoolSize 方法，
            // 如果开发者将 maximumPoolSize 调小了，导致其小于当前的 workers 数量，
            // 那么意味着超出的部分线程要被关闭。重新进入 for 循环，自然会有部分线程会返回 null
            int c = ctl.get();
            int rs = runStateOf(c);
            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                // CAS 操作，减少工作线程数
                decrementWorkerCount();
                return null;
            }
            int wc = workerCountOf(c);
            // Are workers subject to culling?
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }
            try {
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
            // 如果此 worker 发生了中断，采取的方案是重试
            // 解释下为什么会发生中断，这个读者要去看 setMaximumPoolSize 方法，
            // 如果开发者将 maximumPoolSize 调小了，导致其小于当前的 workers 数量，
            // 那么意味着超出的部分线程要被关闭。重新进入 for 循环，自然会有部分线程会返回 null
                timedOut = false;
            }
        }
}

四、线程池执行流程

线程池的执行流程如下图：

五、总结

本文总结以问答的形式展示，引自《深度解读 java 线程池设计思想及源码实现》，最下方附参考地址。

1、线程池有哪些关键属性？

• corePoolSize 到 maximumPoolSize 之间的线程会被回收，当然 corePoolSize 的线程也可以通过设置而得到回收（allowCoreThreadTimeOut(true)）。

• workQueue 用于存放任务，添加任务的时候，如果当前线程数超过了 corePoolSize，那么往该队列中插入任务，线程池中的线程会负责到队列中拉取任务。

• keepAliveTime 用于设置空闲时间，如果线程数超出了 corePoolSize，并且有些线程的空闲时间超过了这个值，会执行关闭这些线程的操作

• rejectedExecutionHandler 用于处理当线程池不能执行此任务时的情况，默认有抛出 RejectedExecutionException 异常、忽略任务、使用提交任务的线程来执行此任务和将队列中等待最久的任务删除，然后提交此任务这四种策略，默认为抛出异常。

2、线程池中的线程创建时机？

• 如果当前线程数少于 corePoolSize，那么提交任务的时候创建一个新的线程，并由这个线程执行这个任务；

• 如果当前线程数已经达到 corePoolSize，那么将提交的任务添加到队列中，等待线程池中的线程去队列中取任务；

• 如果队列已满，那么创建新的线程来执行任务，需要保证池中的线程数不会超过 maximumPoolSize，如果此时线程数超过了 maximumPoolSize，那么执行拒绝策略。

3、任务执行过程中发生异常怎么处理？

如果某个任务执行出现异常，那么执行任务的线程会被关闭，而不是继续接收其他任务。然后会启动一个新的线程来代替它。

4、什么时候会执行拒绝策略？

• workers 的数量达到了 corePoolSize，任务入队成功，以此同时线程池被关闭了，而且关闭线程池并没有将这个任务出队，那么执行拒绝策略。这里说的是非常边界的问题，入队和关闭线程池并发执行，读者仔细看看 execute 方法是怎么进到第一个 reject(command) 里面的。
• workers 的数量大于等于 corePoolSize，准备入队，可是队列满了，任务入队失败，那么准备开启新的线程，可是线程数已经达到 maximumPoolSize，那么执行拒绝策略。

六、参考资料

书籍：《码出高效：Java开发手册》

Java核心技术36讲：http://t.cn/EwUJvWA

深度解读 java 线程池设计思想及源码实现：https://javadoop.com/post/java-thread-pool

Java线程池-ThreadPoolExecutor源码解析(基于Java8)：https://www.imooc.com/article/42990

课程推荐：

java多线程高并发学习笔记——深入理解线程池

线程池最核心的一个类：ThreadPoolExecutor.看一下该类的构造器：　　publicThreadPoolExecutor(intparamInt1,intparamInt2,longparamLong,TimeUnitparamTimeUnit,BlockingQueue<Runnable>paramBlockingQueue){this(paramInt1,paramIn 查看详情

完全解析线程池threadpool原理&使用(代码片段)

...功能，具体设置时机=创建线程池类对象时传入  ThreadPoolExecutor类=线程池的真正实现类 开发者可根据不同需求配置核心参数，从而实现自定义线程池//创建线程池对象如下//通过构造方法配置核心参数Executorexecutor= 查看详情

深入浅出java多线程之threadpool（上）(代码片段)

...。可以说，进程中包含了多个可以同时运行的线程。ThreadPool线程池原理​所谓线程池，通俗的理解就是有一个池子，里面存放着已经创建好的线程，当有任务提交给线程池执行时，池子中的某个线程会主动执... 查看详情

浅理解java中的线程池

浅理解java中的线程池线程池（threadpool）1.线程池的概念2.线程池的工作机制3.使用线程池的原因4.线程池相关概念5.线程池的主要参数6.java中提供的线程池6.1newCachedThreadPool6.2newFixedThreadPool6.3newSingleThreadExecutor6.4newScheduledThrea... 查看详情

threadpool线程池(代码片段)

...线程一个、创建后不销毁、无限队列3*/4privatestaticvoidsingleThreadPool()5ExecutorServiceexecutor=Executors.newSingleThreadExecutor();6for(inti=0;i<10;i++)7executor.execute(newMyRunable(i));89//执行完后销毁线程池10executor.shutdown();11  newFixedThreadPool核心... 查看详情

java多线程：threadpool（中）

您好，我是湘王，这是我的51CTO博客，欢迎您来，欢迎您再来～线程池是个神器，用得好会非常地方便。本来觉得线程池的构造器有些复杂，即使讲清楚了对今后的用处可能也不太大，因为有一些Java定义好的线程池可以直接使用... 查看详情

浅理解java中的线程池(代码片段)

浅理解java中的线程池线程池（threadpool）1.线程池的概念2.线程池的工作机制3.使用线程池的原因4.线程池相关概念5.线程池的主要参数6.java中提供的线程池6.1newCachedThreadPool6.2newFixedThreadPool6.3newSingleThreadExecutor6.4newScheduledThrea... 查看详情

07深入理解java线程池

之前面试baba系时遇到一个相对简单的多线程编程题，即"3个线程循环输出ADC"，自己答的并不是很好，深感内疚，决定更加仔细的学习《并发编程的艺术》一书，到达掌握的强度。（之前两月休息时间都花在了lol和吃鸡上... 查看详情

elasticsearch的底层模块深入解析之threadpool

参考技术A每个es节点内部多有很多个threadpool，不同的threadpool会处理不同的请求，threadpoolmodule就是用来对各种各样的threadpool进行管理的每种threadpool都是绑定了一个queue的，因为threadpool的大小是有限的，比如一个threadpool内部就是... 查看详情

java学习---深入理解线程池

【原文】https://www.toutiao.com/i6566022142666736131/我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建... 查看详情

深入理解java线程池的实现原理(代码片段)

文章目录1线程状态2线程池2.1线程池的作用2.2线程池的实现2.2.1线程池内部状态1线程状态既然要说线程，我们就先来了解一下线程的几种状态：publicenumStateNEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED;如上述代码所示，其... 查看详情

java并发编程系列34|深入理解线程池（下）

Java并发编程系列34|深入理解线程池（下）收录于话题#java976#程序员2286#并发编程238#进阶架构师|并发编程专题12★★★建议星标我们★★★公众号改版后文章乱序推荐，希望你可以点击上方“Java进阶架构师”，点击右上角，将我... 查看详情

原创java并发编程系列33|深入理解线程池（上）

【原创】Java并发编程系列33|深入理解线程池（上）收录于话题#并发编程238#程序员2286#java976#进阶架构师|并发编程专题12★★★建议星标我们★★★公众号改版后文章乱序推荐，希望你可以点击上方“Java进阶架构师”，点击右上... 查看详情

深入理解java线程池：threadpoolexecutor

线程池介绍在web开发中，服务器需要接受并处理请求，所以会为一个请求来分配一个线程来进行处理。如果每次请求都新创建一个线程的话实现起来非常简便，但是存在一个问题：如果并发的请求数量非常多，但每个线程执行的... 查看详情

深入浅出java线程池(代码片段)

课程目标【理解】线程池基本概念【理解】线程池工作原理【掌握】自定义线程池【应用】java内置线程池【应用】使用java内置线程池完成综合案例1.线程池基础1.1.什么是池？连接池1.2.什么是线程池线程池其实就是一种多线... 查看详情

深入浅出java线程池(代码片段)

课程目标【理解】线程池基本概念【理解】线程池工作原理【掌握】自定义线程池【应用】java内置线程池【应用】使用java内置线程池完成综合案例1.线程池基础1.1.什么是池？连接池1.2.什么是线程池线程池其实就是一种多线... 查看详情

浅理解java中的线程池(代码片段)

浅理解java中的线程池线程池（threadpool）1.线程池的概念2.线程池的工作机制3.使用线程池的原因4.线程池相关概念5.线程池的主要参数6.java中提供的线程池6.1newCachedThreadPool6.2newFixedThreadPool6.3newSingleThreadExecutor6.4newScheduledThrea... 查看详情

并发编程与技术内幕:线程池深入理解

【本文转载自博主林炳文Evankaka原创文章http://blog.csdn.net/evankaka】 目录：一Executors的API介绍二几种不同的ExecutorService线程池对象三线程池一些常用方法四ThreadPoolExecutor技术内幕五自定义线程池      摘要... 查看详情