java线程池

一、线程池的好处

1、为什么需要使用线程池

• 反复创建线程开销大 （内存和垃圾回收）
• 过多的线程会导致内存消耗
• 线程池可以规避上述问题，它可以复用每一个线程，并且还可以控制线程总量，便于管理

3、不使用线程池会怎么样

• 每次创建和销毁线程都需要资源的开销，会有很大部分的资源浪费
• 任务数量过多时,新建线程过多可能会OOM异常，即内存溢出。

5、线程池的优点

• 加快响应速度
• 便于线程的管理控制，方便数据统计
• 限制线程资源的总量，合理利用CPU和内存

6、线程池适合的场合

• 服务器接受到大量请求时，使用线程池技术是非常合适的，它可以大大减少线程的创建和销毁次数，提高服务器的工作效率；
• 实际上，在开发中，如果需要创建5个以上的线程，那么就可以使用线程池来管理

二、创建和停止线程池

1、线程池构造函数的参数

参数	类型	含义
corePoolSize	int	核心线程数
maxPoolSize	int	最大线程数
keepAliveTime	long	保持存活时间
workQueue	BlockingQueue	任务存储队列
threadFactory	ThreadFactory	当线程池需要新的线程的时候，会使用threadFactory来生成新的线程
Handler	RejectedExecutionHandler	由于线程池无法接受你所提交的任务的拒绝策略

（1）corePoolSize

核心线程池大小， 线程池初始化后，默认是没有任何线程的，当新的任务到线程池后，线程池会创建新的线程（即使有空闲线程），直到核心线程池已满。

(2) maxPoolSize：

最大线程池大小，顾名思义，线程池能创建的线程的最大数目.

什么情况下线程数量会超过 corePoolSize ，增加到 maxPoolSize ？

• 新任务到来时，如果线程数小于corePoolSize ，即使其他工作线程处于空闲状态，也会创建一个新线程来运行新任务；

• 如果线程数等于或大于corePoolSize 但是少于maxPoolSize，则将任务放入workQueue队列（指定队列的容量）；

• 如果队列已满，并且线程数小于maxPoolSize，则创建一个新线程来运行任务；

• 如果队列已满，并在线程数等于或大于maxPoolSize，则执行Handler拒绝策略；

  总之，是否需要增加线程的判断顺序是：corePoolSize -》workQueue-》maxPoolSize

线程池的线程数量增减的特点

• 通过corePoolSize 和maxPoolSize相同，就可以创建固定大小的线程池；
• 线程池希望保持较少的线程数，并且只有在负载变得很大的时候才增加它；
• 通过设置maxPoolSize为很高的值，可以允许线程池容纳任意数量的并发任务；
• 只有在队列填满时才多于corePoolSize 的线程，所以如果你使用的是无界队列，那么线程数就不会超过corePoolSize ；

（3）keepAliveTime：

如果线程池当前的线程数多于corePoolSize ，其中多余的那部分线程空闲时间超过keepAliveTime，它们就会被终止，比如：corePoolSize 为5，当前线程数为10，如果线程空闲了，就会恢复到5；

(4) ThreadFactory：

用来创建线程，默认是非守护线程，优先级是5，一共有10个等级；

(5) workQueue：

一个阻塞队列，用来存储等待执行的任务，有3种最常见的队列类型：

• 直接交接：SynchronousQueue，一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。
• 无界队列：LinkedBlockingQueue，一个基于链表结构的阻塞队列，此队列按FIFO （先进先出） 排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法 Executors.newFixedThreadPool() 使用了这个队列。队列的容量没有上限，有可能造成OOM。
• 有界队列：ArrayBlockingQueue，是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序。

(6) RejectedExecutionHandler

当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取一种策略处理提交的新任务。有下面四种JDK提供的策略：

• AbortPolicy，表示无法处理新任务时抛出异常, 默认策略
• CallerRunsPolicy：用调用者所在线程来运行任务，即谁给的任务谁来执行
• DiscardOldestPolicy： 该策略将丢弃最老的一个请求，也就是即将被执行的任务，并尝试再次提交当前任务。
• DiscardPolicy：不处理，丢弃掉

除了这些JDK提供的策略外，还可以自己实现 RejectedExecutionHandler 接口定义策略。

2、线程池创建

Excutors类提供的创建线程池的方法如下：

(1) newFixedThreadPool

创建固定大小的线程池，核心线程数和最大线程数相等。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。
线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。

• 源码：

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

• 使用演示：

/**
  *          演示newFixedThreadPool
 */
public class FixedThreadPoolTest {
    //主函数
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(4);

        //执行线程池
        for (int i = 0; i < 1000; i++) {
            threadPool.execute(new Task());
        }
    }

    //任务类
    static class Task implements Runnable {
        @Override
        public void run() {
            try {
                Thread.sleep(500);
                System.out.println(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

打印结果：

发现提交1000个任务，却只有4个线程在执行任务，跟我们设定4个线程执行要求是一致的

• 错误演示

当因为任务过多无法处理导致内存资源耗尽

/**
 *      演示newFixedThreadPool出错的情况
 */
public class FixedThreadPoolOOM {
    //线程池
    private static ExecutorService executorService = Executors.newFixedThreadPool(1);

    public static void main(String[] args) {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            //执行任务
            executorService.execute(new SubThread());
        }
    }
}

//任务类
class SubThread implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(1000000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

为了更块地看到内存溢出，我们可以主动设置jvm参数，如下

最后出现了内存溢出OOM

由于使用的 LinkedBlockingQueue是没有容量上限的，所以当请求数越来越多，并且无法及时处理完毕的时候，也就是请求堆积的时候，会容易造成占用大量的内存，可能会导致OOM。

(2) newSingleThreadExecutor

创建一个单线程的线程池。这个线程池只有一个线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。

• 源码

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

从源码可以看出，这里和刚才的newFixedThreadPool的原理基本一样，只不过把线程数直接设置成了1，所以这也会导致同样的问题，也就是当请求堆积的时候，可能会占用大量的内存。

• 使用演示

public class SingleThreadExecutor {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 1000; i++) {
            executorService.execute(new Task());
        }

    }
}
 class Task implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(500);
            System.out.println(Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

打印结果如下，始终只有一个线程名字，说明只有一个线程：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vmwxfRkR-1686042155717)(null)]

(3) newCachedThreadPool

创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。
此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小, 极端情况下会因为创建过多线程而耗尽系统资源，引发OOM

• 特点：一个采用SynchronousQueue的无界限线程池，具有60s自动回收多余线程的功能
• 源码：

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

• 使用演示

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

        for (int i = 0; i < 1000; i++) {
            pool.execute(new Task());
        }
    }

    static class Task implements Runnable{
        @Override
        public void run() {
            try {
                Thread.sleep(500);
                System.out.println(Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

打印结果

可以看到，每一个新任务，都会创建一个线程，他创建了1000个线程

（4）newScheduledThreadPool

• 主要用来在给定的延迟之后运行任务，或者定期执行任务。
• 源码

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

• 使用演示

public class ScheduleThreadPool {
    public static void main(String[] args) {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(10);

        //5秒钟执行任务，不重复执行
//        pool.schedule(new Task(),5, TimeUnit.SECONDS);

        //一开始1后执行任务，后面每隔3秒执行
        pool.scheduleAtFixedRate(new Task(),1,3,TimeUnit.SECONDS);
    }
}

打印结果：

由于设置了 corePoolSize=10,所以会出现10个线程，这10个线程执行的是同一个任务：一开始1s后执行任务，后面每隔3秒执行一次

（5）newWorkStealingPool

newWorkStealingPool 是jdk1.8才有的，会根据所需的并行层次来动态创建和关闭线程，通过使用多个队列减少竞争，底层用的 ForkJoinPool来实现的。ForkJoinPool 的优势在于，可以充分利用多cpu，多核cpu的优势，把一个任务拆分成多个“小任务”，把多个“小任务”放到多个处理器核心上并行执行；当多个“小任务”执行完成之后，再将这些执行结果合并起来即可。

五种线程池的使用场景

• newSingleThreadExecutor：一个单线程的线程池，可以用于需要保证顺序执行的场景，并且只有一个线程在执行。
• newFixedThreadPool：一个固定大小的线程池，可以用于已知并发压力的情况下，对线程数做限制。
• newCachedThreadPool：一个可以无限扩大的线程池，比较适合处理执行时间比较小的任务。
• newScheduledThreadPool：可以延时启动，定时启动的线程池，适用于需要多个后台线程执行周期任务的场景。
• newWorkStealingPool：一个拥有多个任务队列的线程池，可以减少连接数，创建当前可用cpu数量的线程来并行执行。

以上都是使用 Executors 提供的方法创建线程池，不过更建议直接使用ThreadPoolExecutor 创建线程池,这样我们就能根据不同的业务场景，自己设置线程池参数，比如我们的内存有多大，我们想给线程取什么名字等等

3、线程池设定线程数量如何选择？

• CPU密集型：比如八核处理器，那可以把corePoolSize 设置为核心数的1-2倍；
• 耗时IO型（读写文件）：这种类型的CPU是不工作的，可以设置为核心数的很多倍
• 线程数=CPU核心数*（1+平均等待时间/平均工作时间）

4、停止线程的正确方法

(1) shutdown:

初始化整个关闭过程，不是直接关闭，把正在执行以及队列中等待的任务执行完毕再关闭，然后拒绝新的任务；

使用演示：

public class StopThreadPool {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 50; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(500);
                        System.out.println("执行已经提交的线程:" +Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        Thread.sleep(1000);
        executorService.shutdown();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("继续提交线程池");
            }
        });
    }
}

打印结果：

可以看出，shutdown后，再次提交是被拒绝的，抛出异常：RejectedExecutionException，但是已经提交的任务会慢慢执行完毕。

(2) isShutdown、isTerminated、awaitTermnation、shutdownNow

• isShutdown：判断是否被shutdown了；
• isTerminated：判断线程池是否完全终止；
• awaitTermnation：检测一段时间后线程池是否完全终止，是用来检测的；
• shutdownNow：立刻停止线程池，立刻停止的过程：利用线程InterruptedException中断抛出异常停止线程，同时该方法会返回一个集合，包含已经放进队列中还没来得急执行的线程对象；

//演示关闭线程池
public class ShutdownPool {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 100; i++) {
            pool.execute(new ShutdownTask());
        }

        Thread.sleep(1500);

        pool.shutdownNow();

          boolean flag = pool.awaitTermination(3, TimeUnit.SECONDS);
          System.out.println(flag);
          System.out.println(pool.isShutdown());
          Thread.sleep(10000);
          System.out.println(pool.isTerminated());
          //再次执行任务
          pool.execute(new ShutdownTask());
    }
}

class ShutdownTask implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(500);
            System.out.println(Thread.currentThread().getName());
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName()+": 被中断了");
        }
    }
}

打印结果：

三、常见线程池的特点和用法

线程池创建方法	corePoolSize	maxPoolSize	keepAliveTime	workQueue
newFixedThreadPool	指定	等于maxPoolSize	0s	LinkedBlockingQueue
newSingleThreadExecutor	1	1	0s	LinkedBlockingQueue
newCachedThreadPool	0	Integer.MAX_VALUE	60s	SynchronousQueue
newScheduledThreadPool	指定	Integer.MAX_VALUE	0s	DelayedWorkQueue

四、任务太多，怎么拒绝？

1、拒绝时机

出现以下其中一种情况时，会拒绝：

• 一旦线程池shutDown，后续的任务就被拒绝了；
• 当Executor对最大线程maxPoolSize 和工作队列容量使用ArrayBlockingQueue有限边界并饱和时候，就直接拒绝了；

2、拒绝策略

• AbortPolicy，抛出异常；
• DiscardPolicy，默默抛弃，不抛出异常；
• DiscardOldestPolicy，丢弃最老的，存在时间最久的任务给丢掉；
• CallerRunsPolicy，如果线程池没办法处理，谁提交的任务谁去跑，比如主线程提交的任务，那么线程池饱和的情况下，就交还给主线程执行这个任务；

3、钩子方法

每个任务执行前后，可以放置钩子方法，来做一些事情，比如日志、统计等；

//演示任务前后，可有钩子桉树
public class PauseableThreadPool extends ThreadPoolExecutor {
    private boolean isPaused;//标记位
    private final ReentrantLock lock = new ReentrantLock();//锁
    private final Condition unpaused = lock.newCondition();//类似wait/notify...

    //主函数
    public static void main(String[] args) throws InterruptedException {
        PauseableThreadPool pool = new PauseableThreadPool(10, 20, 10L, TimeUnit.SECONDS, new LinkedBlockingDeque<>());
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("我被执行");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        for (int i = 0; i < 10000; i++) {
            pool.execute(task);
        }

        Thread.sleep(1500);

        pool.pause();
        System.out.println("线程池被暂停了。。。。。。。。。。");

        Thread.sleep(1500);

        pool.resume();
        System.out.println("线程池恢复了。。。。。。。。。。。。");

    }

    //钩子函数，任务执行前
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        lock.lock();
        try {
            while (isPaused) {
                //暂停线程
                unpaused.await();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //暂停
    private void pause() {
        lock.lock();
        try {
            isPaused = true;
        } finally {
            lock.unlock();
        }
    }

    //恢复
    private void resume() {
        lock.lock();
        try {
            isPaused = false;
            //唤醒线程
            unpaused.signalAll();
        } finally {
            lock.unlock();
        }
    }
    
    //下面↓↓↓ 是继承 ThreadPoolExecutor 默认实现的，不用管
    public PauseableThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

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

    public PauseableThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
    }

    public PauseableThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
    }
}

打印结果：

五、线程池实现原理

1、线程池组成部分

• 线程池管理器
• 工作线程
• 任务队列
• 任务接口（Task）

2、Executor家族

• Executor：接口，ExecutorService继承于Executor ；

• Executors：工具类，帮我们自动创建线程池，类似于Collections；

• ThreadPoolExecutor：线程池类，ThreadPoolExecutor继承于ExecutorService；

所以，Executor、ExecutorService、ThreadPoolExecutor都是线程池类型，只不过是继承关系；

3、线程池实现任务复用

相同线程执行不同任务，调用新的任务的run方法，在while中不停的循环执行

   // 源码
   final void runWorker(Worker w) {
        Runnable task = w.firstTask;
        while (task != null || (task = getTask()) != null) {
           task.run();
       }
    }

在runWork中，拿到一个又一个的task，while循环中判断如果不为空，则执行完毕task的run方法，如果task为空，即执行完毕了一个任务，则用getTask方法去取下一个任务，直到没有任务了。

4. execute()方法的源码

线程池的运行原理图：

结合上面的线程池运行原理图和下面的execute() 方法源码，梳理一下线程池的执行过程：

public void execute(Runnable command) {
    //判断提交的任务是否为 null, 是则抛出异常,commond:指接下来要执行的任务
    if (command == null)
        throw new NullPointerException();

    /*
     * 获取线程池控制状态
     * ctl 是一个 AtomicInteger 变量 （骚操作）
     * jdk 8 中通过一个 int 值的前 28 位表示工作线程数量 workerCount, 剩余高位来表示 线程池状态
     * 计算 workerCount 和 runState 时通过掩码计算。  CAPACITY = (1 << 29) - 1
     * private static int runStateOf(int c)     { return c & ~CAPACITY; }
     * private static int workerCountOf(int c)  { return c & CAPACITY; }
     * */
    int c = ctl.get();

    //1. 当线程数小于 核心线程池容量时 将添加工作线程去执行任务

    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true)) // 这里的 core 为 true,表示当前线程数小于核心线程数，添加的线程在 核心线程数范围内，为false就是超过核心线程数，但是在最大线程数范围内
            return; 
        c = ctl.get(); // 不成功则再次获取线程池控制状态
    }

    //2. （worker线程数量大于核心线程池容量时）如果线程池处于 RUNNING 状态，将命令加入 workQueue 队列
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get(); //再次检查防止状态突变
        if (! isRunning(recheck) && remove(command)) 
            //2.1 如果状态改变，线程池没有 RUNNING 则将命令移出队列，并拒绝执行
            reject(command); 
        else if (workerCountOf(recheck) == 0) 
            //2.2 状态没有改变，线程池 RUNNING，但 worker线程数量为 0， 则添加非core的worker线程
             addWorker(null, false);
    }

    //3. 如果线程池没有 RUNNING 并尝试添加非core的 worker 线程失败，那就拒绝执行
    else if (!addWorker(command, false)) 
        reject(command);
}

• 如果运行的线程小于 corePoolSize，则尝试使用用户定义的 Runnalbe 对象创建一个新的线程。调用 addWorker() 函数会原子性的检查runState 和 workCount，通过返回 false 来防止在不应该添加线程时添加了线程
• 如果一个任务能够成功入队列，在添加一个线程时仍需要进行双重检查（可能因为在前一次检查后该线程死亡了），或者当进入到此方法时，线程池已经shutdown了，所以需要再次检查状态。若线程此时的状态不是 RUNNING，则需要回滚入队列操作；或者当线程池没有工作线程时，需要创建一个新的工作线程。
• 如果无法入队列，那么需要增加一个新工作线程，如果此操作失败，那么就意味着线程池已经 SHUTDOWN 或者已经饱和了，所以拒绝任务

addWorker()方法的源码

此方法用来创建新的线程添加到线程池

private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
        /*
         * 检查线程池状况， 确保此时可以添加新的线程，
         * 如果是runing，那么跳过if。
         * 如果rs>=SHUTDOWN,同时不等于SHUTDOWN，即为SHUTDOWN以上的状态，那么不接受新线程。
         * 如果rs>=SHUTDOWN，同时等于SHUTDOWN，同时first != null，那么拒绝新线程，
         * 如果为Empty，那么队列已空，不需要增加消耗线程，返回 false。
         * */
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;
        for (;;) {
            int wc = workerCountOf(c);
            /* 
             * 判断线程池是否已满，如果线程数大于等于最大容量 CAPACITY 直接返回false
             * core 是一个boolean 参数，表明调用者想把此线程添加到哪个线程池
             * 根据 core 的值判断要添加的线程池是否已满
             **/
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            //CAS 操作增加工作线程数
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
            //CAS 操作失败， 再次检查状态重来一次
            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());
                //确保当前线程池还接收新的线程
                //结合上面的线程状态知道：当状态值大于等于 SHUTDOWN 时 线程池就不再接收新的线程了
                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();
            }
            if (workerAdded) {
                //线程添加成功后就可以启动线程准备执行了
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

从上面两段源码可以看到， 在添加新的线程进入线程池时，各种操作非常的严谨细致，往往需要多次检查状态，确保线程池的正确运行。

worker工作线程的源码

线程池创建线程时，会将线程封装成工作线程Worker，Worker在执行完任务后，还会无限循环获取工作队列里的任务来执行。我们可以从Worker的runWorker方法里看到：

final void runWorker(Worker w) {
    // 获取当前线程
    Thread wt = Thread.currentThread();
    // 获取w的firstTask
    Runnable task = w.firstTask;
    // 设置w的firstTask为null
    w.firstTask = null;
    // 释放锁（设置state为0，允许中断）
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        while (task != null || (task = getTask()) != null) { // 任务不为null或者阻塞队列还存在任务
            // 获取锁
            w.lock();
            /*
             * 这里的检查主要是确保线程池此时还能接收新的任务去执行， 如果不在接收新的任务
             * 则应该中断当前线程
             **/
            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;
                // 增加给worker完成的任务数量
                w.completedTasks++;
                // 释放锁
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        // 处理完成后，调用钩子函数
        processWorkerExit(w, completedAbruptly);
    }
}

5. 线程池的状态

• RUNNING：接收新任务并处理排队任务，即执行execute后的状态；
• SHUTDOWN：不接受新任务，但是处理排队任务，即执行shutdown方法后的状态；
• STOP：不接受新任务，也不处理排队的任务，并中断正在进行的任务，即执行shutdownNow方法后的状态；
• TIDYING：整洁，所有任务都已经终止，线程会转到TIDYING状态，并将运行 terminated() 方法；
• TERMINATED：终止状态, terminated()方法完成；

状态转换图：

六、使用线程池的注意点

• 避免任务堆积
• 避免线程数过度增加
• 排查线程泄漏：指线程执行完任务不能被回收，一般都是任务的逻辑出现问题，任务无法真正结束，现成也就无法被回收

点击关注我的公众号：点我关注

文章来源：java线程池

个人微信：CaiBaoDeCai

微信公众号名称：Java知者

微信公众号 ID： JavaZhiZhe

谢谢关注！