初识线程池就看它!你，学废了吗？

前言

​ 笔者为大三在读学生，秋招复习刚好看到线程这一块儿，因此写下本文作为java线程池基础知识的介绍和总结，如果有错误的地方欢迎留言哟，十分期待与各位的思维碰撞！

​ 本文参考自《Java并发编程之美》、b站尚硅谷周阳老师《面试第二季》视频、jdk源码。

线程池的好处

​ 根据我们以前学过的知识，我们知道线程创建的方式有三种：继承Thread类并重写run方法、实现Runnable接口并实现run方法、使用FutureTask。当请求来时，按照传统的方法需要不停的使用new操作创建线程，线程任务执行完毕时，又需要进行销毁。我们知道，java线程是依赖于操作系统的线程的，线程是十分稀缺的资源，线程的创建和销毁都是很耗时的操作。一方面，如果无限制的创建和销毁资源，是一件代价非常大的事情；另一方面，当请求来时，用户需要等待线程创建完成后才能执行任务。

​ 线程池的好处：

• 降低资源消耗。通过重复利用已创建的线程来执行任务，可以减少因频繁创建和销毁线程带来的资源消耗。
• 响应时间快。用户请求来时，可以直接使用线程池中已存在的线程执行任务，而不需要等待线程创建的过程。
• 对线程进行控制和管理。使用线程池可以限制线程的个数，可以管理线程。

线程池的创建方式

​ 常用的线程池创建方式有：

1. 使用Executors工具类提供的接口创建线程池；
2. 使用ThreadPoolExecutor类的构造方法创建线程池

使用Executors的接口

常用的线程池为FixedThreadPool、SingleThreadPool、CachedThreadPool

结合这几个接口的源码来进行分析：

//  FixedThreadPool
/**
 * 创建一个最大核心线程数和最大线程数都为nThreads的线程池
 * keepAliveTime为0说明：在当前线程数大于核心线程数时，一旦线程空闲则就被销毁
 * 阻塞队列采用的是LinkedBlockingQueue，队列中最多可以容纳Integer.MAX_VALUE个任务
 */
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

// SingleThreadExecutor
/**
 * 创建一个最大核心线程数和最大线程数都为1的线程池
 * keepAliveTime为0说明：在当前线程数大于核心线程数时，一旦线程空闲则就被销毁
 * 阻塞队列采用的是LinkedBlockingQueue，队列中最多可以容纳Integer.MAX_VALUE个任务
 */
public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
// 	CachedThreadPool
/**
 * 该线程池是一个按需创建线程的线程池，最大核心线程数为0，最大线程数为Integer.MAX_VALUE
 * keepAliveTime为60L，unit为TimeUnit.SECONDS说明如果线程口空闲超过了60s，就会被销毁
 * 阻塞队列采用的是SynchronousQueue，队列中最多可以容纳1个任务
 */
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

通过阅读Executors几个方法的源码我们可以发现，这几个方法只是对new ThreadPoolExecutor()操作的封装，同时也表明，创建线程池的底层实际还是调用ThreadPoolExecutor的构造方法。

使用ThreadPoolExecutor构造方法

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }
// 最核心的构造方法，七个参数
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的七个参数

• int corePoolSize：线程池中最大核心线程数
• int maximumPoolSize：线程池中最大线程数，包括核心线程在内的最大线程数
• long keepAliveTime：当线程池中线程数大于corePoolSize时，如果某非核心线程空闲时间超过keepAliveTime,则该线程会被销毁
• TimeUnit unit：keepAliveTime的时间单位，与keepAliveTime配合使用
• BlockingQueue workQueue：阻塞队列。当核心线程数满时，存放任务
• ThreadFactory threadFactory：创建线程的工厂。封装了newThread方法用于创建线程
• RejectedExecutionHandler handler：拒绝策略。当线程池中的线程都在执行任务并且队列已满时，对新任务的处理策略，有四种：AbortPolicy、CallerRunsPolicy、DiscardPolicy、DiscardOldestPolicy，默认为AbortPolicy

线程池初体验

==下面我们通过一小段代码体验一下通过new ThreadPoolExecutor()创建线程池，并体会上面四种拒绝策略==

class MyTask implements Runnable {
    private Integer val;

    public MyTask(Integer val) {
        this.val = val;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread() + " running task :" + String.valueOf(val));
    }
}

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(1, 2,
                                                        0L, TimeUnit.SECONDS,
                                                        new LinkedBlockingQueue<>(2),
                                                        Executors.defaultThreadFactory(),
                                                        //new ThreadPoolExecutor.AbortPolicy());
                                                        //new ThreadPoolExecutor.CallerRunsPolicy());
                                                        //new ThreadPoolExecutor.DiscardOldestPolicy());
                                                        new ThreadPoolExecutor.DiscardPolicy());

        // 前提条件：当核心线程都在执行任务、队列中任务已经放满、非核心线程也都在执行任务

        // AbortPolicy:拒绝策略。
        // 若此时新传来一个任务，就会直接抛出异常，拒绝执行新的任务
        /*
        Thread[pool-1-thread-1,5,main] running task :0
        Thread[pool-1-thread-2,5,main] running task :3
        Thread[pool-1-thread-2,5,main] running task :1
        Thread[pool-1-thread-1,5,main] running task :2
        java.util.concurrent.RejectedExecutionException: Task test.threadpool_study.MyTask@511d50c0 rejected from java.util.concurrent.ThreadPoolExecutor@60e53b93[Running, pool size = 2, active threads = 2, queued tasks = 2, completed tasks = 0]
	    at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2047)
	    at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:823)
	    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1369)
	    at test.threadpool_study.ThreadPoolDemo.main(ThreadPoolDemo.java:60)
         */

        // CallerRunsPolicy：调用者执行策略。
        // 若此时新传来一个任务，线程池中的线程无法执行该任务，也无法将该任务存放到阻塞队列中
        // 那么该任务就会由调用者线程执行。如：main线程里面进行提交任务，该任务就会由main线程来执行。
        /*
            Thread[pool-1-thread-1,5,main] running task :0
            Thread[pool-1-thread-2,5,main] running task :3
            Thread[pool-1-thread-1,5,main] running task :1
            Thread[main,5,main] running task :4   // 由main线程执行的任务!!!
            Thread[pool-1-thread-2,5,main] running task :2
            Thread[pool-1-thread-2,5,main] running task :5
         */

        // DiscardOldestPolicy：丢弃队列中的一个任务，执行当前任务
        // 此时会调用poll方法丢弃一个任务
        /*
            Thread[pool-1-thread-1,5,main] running task :0
            Thread[pool-1-thread-2,5,main] running task :3
            Thread[pool-1-thread-1,5,main] running task :4
            Thread[pool-1-thread-2,5,main] running task :5
         */

        // DiscardPolicy：默默丢弃新提交的任务，但也不会抛出异常
        /*
            Thread[pool-1-thread-1,5,main] running task :0
            Thread[pool-1-thread-2,5,main] running task :3
            Thread[pool-1-thread-1,5,main] running task :1
            Thread[pool-1-thread-2,5,main] running task :2

         */
        try {
            for (int i = 0;i < 6;i++) {
                pool.execute(new MyTask(i));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            pool.shutdown();
        }
    }
}

​ 通过以上学习我们了解了两种创建线程池的方式，但是在开发过程中应该使用哪种方式呢？

《阿里巴巴Java开发手册》中有此建议：

【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式， 这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

说明：Executors 各个方法的弊端：

1）newFixedThreadPool 和 newSingleThreadExecutor:

主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至 OOM。

2）newCachedThreadPool 和 newScheduledThreadPool:

主要问题是线程数最大数是 Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至 OOM。

​ 以上是我们对线程池的初步了解与使用，接下来我们要从源码的角度去探一探线程池。

初识线程池原理

ThreadPoolExecutor类图：(图片来源：《Java并发编程之美》)

​ ThreadPoolExecutor内部有一个原子变量ctl，其可以用于记录线程池的状态以及线程池中线程的数量，这一点与读写锁ReentrantReadWriteLock使用一个state来记录读写锁状态类似。ctl变量的高三位用于表示线程池状态，后面的位数用于表示线程池中线程的数量。假设我们用bits表示当前系统下Integer变量的位数，即bits=Integer.size。设COUNT_BITS=bits - 3,所以线程最大数量Capacity=（1<<COUNT_BITS）- 1。

​ 线程池有5种状态：RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED。

​ 这五种状态的值以及解释如下：

• RUNNING：-1 << COUNT_BITS(1110 00...00),该状态下线程池接受新的任务，并处理任务
• SHUTDOWN：0 << COUNT_BITS(0000 00...00),该状态下线程池拒绝接受新的任务，但仍然处理队列中的任务 STOP：1 << COUNT_BITS(0010 00...00),该状态下线程池拒绝接受新的任务，不处理队列中的任务，并且停止正 在执行中的任务
• TIDYING：2 << COUNT_BITS(0100 00..00),该状态下线程池中的所有任务都被执行完，当前线程池活动线程数为0
• TERMINATED：3 << COUNT_BITS(0110 00..00),终止状态

Worker是任务的载体，其实现了Runnable和AQS接口。

workQueue就是线程池中存放任务的阻塞队列。Workers是执行任务的线程。mainLock是ThreadPoolExecutor内部的一个锁，用于保证线程池添加创建线程操作的原子性。

在学习线程池几个重要方法之前，我们需要知道几个简单的方法：

// Packing and unpacking ctl
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    private static int ctlOf(int rs, int wc) { return rs | wc; }

execute方法:

​ 用户通过调用ThreadPoolExecutor的execute方法向线程池提交任务。

public void execute(Runnable command) {
        // 判断command非空
        if (command == null)
            throw new NullPointerException();
        
        int c = ctl.get();
        // 判断线程池中线程数是否小于线程池最大核心线程数(corePoolSize),小于则创建一个核心线程执行任务
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        // 如果线程数大于等于corePoolSize,则将任务添加到队列中
        // 线程池只有在RUNNING状态下可以接受新的任务，所以要判断线程池状态
        if (isRunning(c) && workQueue.offer(command)) {
            // 二次校验
            // 在二次校验之前，线程池状态可能发生了改变，那么需要从队列中移除该任务
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                // 拒绝任务
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //  如果队列也满了，则创建一个非核心线程执行任务
        else if (!addWorker(command, false))
            // 如果创建失败，执行拒绝策略
            reject(command);
    }

​ 通过阅读该方法的源码，我们可以初步了解线程池的工作原理：用户向线程池提交任务，判断线程池中核心线程数目是否达到corePoolSize，如果没有达到，则创建一个核心线程执行该任务，否则尝试将任务添加到阻塞队列中等待执行。如果队列未满，则将任务添加到队列中，否则尝试为该任务创建一个普通线程。如果线程池中当前线程数量未达到maximumPoolSize，则创建一个普通线程执行该任务，否则采取拒绝策略。如图所示：

addWorker方法：

​ 创建执行任务的线程。

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // 校验线程池状态
            /**
             * 等价于：
             * rs >= SHUTDOWN &&
             *                 (rs != SHUTDOWN ||
             *                    firstTask != null ||
             *                    workQueue.isEmpty())
             * 也就是在以下几种情况下addWorker方法会返回false：
             * 1、线程池状态为STOP、TIDYING、TERMINATED
             * 2、线程池状态为SHUTDOWN，并且firstTask不为空
             * 3、线程池状态为SHUTDOWN，并且队列为空
             */
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            // CAS添加线程数量
            for (;;) {
                int wc = workerCountOf(c);
                // 判断是核心线程还是非核心线程
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                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锁，防止多个线程同时进行创建线程操作而导致线程安全问题
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    // 校验，防止在将新创建的线程加入到workers前，其他线程改变了线程池状态
                    int rs = runStateOf(ctl.get());

                    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();
                }
                // 将新创建的线程添加到workers成功，则启动线程
                if (workerAdded) {
                    // 启动线程
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

​ 该方法的原理可以简略概括为：首先校验线程池状态，其次再CAS添加线程数。以上操作完成后，真正创建一个Worker，将Worker添加到workers中。如果添加成功，则启动worker执行任务。

worker的构造方法

Worker(Runnable firstTask) {
            /**
             * 初始化时worker的state被置为-1
             * 当其他线程执行线程池的shutdown()方法时，state>=0的线程将被中断
             * 所以用-1来标记被创建出来但还未开始执行的线程
             */
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

​ 在addWorker方法中调用t.start()方法启动线程后，会调用worker的run方法：

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

runWorker方法：

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        // 将worker的state从-1置为0,表示该线程可以被中断了
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            // 如果当前worker的firstTask一直不为空，或者队列里面有待执行的任务
            // 就会一直循环执行任务
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                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) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            // 记录线程池累计完成任务数目，并将worker从workers中移除
            processWorkerExit(w, completedAbruptly);
        }
    }

使用线程池时需要注意的问题

创建线程池时自定义线程池名称

​ 如果满足用户需求需要创建多个线程池，那么创建线程池时需要为每个线程池定义一个唯一的名称，方便于运行过程中抛出异常时准确定位异常抛出的位置。

​ 我们首先看一下defaultThreadFactory中如何生成线程池名称。

static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

​ 我们可以发现线程池创建出的线程名为:namePrefix + threadNumber.getAndIncrement()，同时，该线程所属的线程池名称为pool- + poolNumber.getAndIncrement()。我们可以对namePrefix做些手脚，来实现自定义线程池名称的目的。

static class NamedThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        NamedThreadFactory(String name) {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                    Thread.currentThread().getThreadGroup();
            if (null == name || name.isEmpty()) {
                name = "pool";
            }
            namePrefix = name + "-" +
                    poolNumber.getAndIncrement() +
                    "-thread-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                    namePrefix + threadNumber.getAndIncrement(),
                    0);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

线程池使用完后使用shutdown()方法关闭线程池

​ 线程池使用完后要使用shutdown()方法关闭线程池，否则即使程序执行完了，但是线程池资源一直没有被释放，JVM进程也没有退出。我们由上面的newThread()方法可知，线程池创建的线程都是用户线程，而核心线程是一直存在的，即使没有任务了也只是阻塞但不销毁，所以线程池中的用户线程就会一直存在，JVM进程就无法退出。而shutdown()方法就是让这些核心线程停止，从而使得JVM正常退出。

最后一点想说的

​ 在学习线程池的过程中，我阅读了《Java并发编程之美》这本书，也查阅了网上的一些博客，以及看了《尚硅谷面试第二季》视频中线程池部分的讲解，在这些学习资料的帮助下我才对线程池有了初步的了解。但是当我真正点开我IDEA中ThreadPoolExecutor类的源码时，我才真的傻了眼。阅读源码的过程中我仍遗留下很多问题：为什么workers要用HashSet(我猜测应该是为ScheduledThreadPoolExecutor中将任务根据时间来排序)？为什么要用一个变量来记录线程池状态和线程数量？线程池是如何销毁空闲的非核心线程的？因为这些遗留的问题以及缺乏线程池的真正实践，所以我才将这篇文章标题命名为"初识"，线程池还有太多值得我去学习的地方。文章中有许多话与博客和书上的语言相似，一是我不知如何组织语言方便理解，二是原作者的一些语言已经很精辟了。继续加油，淦!2020-5-21。