Java线程池原理

Chary Liu

于 2021-05-03 14:15:23 发布

阅读量227

点赞数

分类专栏： JAVA 文章标签： java 多线程并发编程面试

本文链接：https://blog.csdn.net/qq_32505207/article/details/116376483

版权

JAVA 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、线程池简介

1.1 为什么要使用线程池

在实际使用中，线程的创建与销毁都是很占用系统资源的，因为java线程依赖于内核线程，创建线程需要操作系统状态切换，如果对线程管理不善很容易导致系统问题。因此，在大多数并发框架中都会使用线程池来负责对线程进行统一分配、调优与监控，使用线程池管理线程主要有如下好处：

降低资源消耗。通过复用已存在的线程和降低线程关闭的次数来尽可能降低系统性能损耗；
提升系统响应速度。通过复用线程，省去创建线程的过程，因此整体上提升了系统的响应速度；
提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，因此，需要使用线程池来管理线程。推荐自定义线程池，动态调整策略。

线程池适合单个任务处理时间比较短，任务数量大的场景

1.2 常见线程池

Java提供的4种线程池：

Executors.newCachedThreadPool ：（快，cpu占用率高）
可缓存线程池，若线程池长度超过处理需要，则回收空线程，否则创建新线程，线程规模可无限大。支持线程复用。
Executors.newFixedThreadPool ：（较慢，OOM）
定长线程池，可控制线程最大并发数，超出的会在队列中等待。
Executors.newSingleThreadExecutor ：（最慢，OOM）
单线程的线程池，支持FIFO, LIFO, 优先级策略。
Executors.newScheduledThreadPool ：
定长线程池，支持定时及周期性任务执行，类似Timer。

1.3 线程池的5种状态

在这里插入图片描述

1、RUNNING
(1) 状态说明：线程池处在RUNNING状态时，能够接收新任务，以及对已添加的任务进行处理。
(2) 状态切换：线程池被创建后的初始化状态是RUNNING，并且线程池中的任务数为0

2、 SHUTDOWN
(1) 状态说明：线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。
(2) 状态切换：调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN。

3、STOP
(1) 状态说明：线程池处在STOP状态时，不接收新任务，不处理已添加的任务，并且会等到一个安全点中断正在处理的任务。
(2) 状态切换：调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) -> STOP。

4、TIDYING
(1) 状态说明：当所有的任务都已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。
(2) 状态切换：当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。
当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。

5、 TERMINATED
(1) 状态说明：线程池彻底终止，就变成TERMINATED状态。
(2) 状态切换：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。

1.4 线程池控制状态ctl

在这里插入图片描述

高3位表示线程池状态，后面低位表示当前工作线程数量

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int COUNT_MASK = (1 << COUNT_BITS) - 1;

// runState is stored in the high-order bits
private static final int RUNNING    = -1 << COUNT_BITS;
private static final int SHUTDOWN   =  0 << COUNT_BITS;
private static final int STOP       =  1 << COUNT_BITS;
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;

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

例如，Running状态下高三位就是111，因为-1的二进制是1的二进制取反再+1，然后再左移29位，高三位就是111了

二、线程池的工作原理

在这里插入图片描述
从图可以看出，线程池执行所提交的任务过程主要有这样几个阶段：

先判断线程池中核心线程池所有的线程是否都在执行任务。如果不是，则新创建一个线程执行刚提交的任务，否则，核心线程池中所有的线程都在执行任务，则进入第 2 步；
判断当前阻塞队列是否已满，如果未满，则将提交的任务放置在阻塞队列中；否则，则进入第 3 步；
判断线程池中所有的线程是否都在执行任务，如果没有，则创建新的线程来执行任务，否则，则交给拒绝策略进行处理

提交优先级
执行优先级

ThreadPoolExecutor 的 execute 方法执行逻辑
在这里插入图片描述
execute 方法执行逻辑有这样几种情况：

线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。
当调用 execute() 方法添加一个任务时，线程池会做如下判断:

如果正在运行的线程数量小于 corePoolSize，则会创建新的线程来执行新的任务；
如果正在运行的线程数量大于或等于 corePoolSize，则会将提交的任务存放到阻塞队列 workQueue 中；
如果当前 workQueue 队列满了，而且正在运行的线程数量小于 maximumPoolSize，则创建非核心线程立刻运行这个任务;
如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会抛出异常RejectExecutionException，使用饱和策略 RejectedExecutionHandler 来进行处理。

当一个线程完成任务时，它会从队列中取下一个任务来执行。
当一个线程无事可做，超过一定的时间(keepAliveTime)时，线程池会判断，如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。

三、线程复用原理

线程重用的核心是，我们知道，Thread.start()只能调用一次，一旦这个调用结束，则该线程就到了terminated状态，不能再次调用start。在线程池中，线程会从 workQueue 中读取任务来执行，最小的执行单位就是 Worker，Worker 实现了 Runnable 接口，重写了 run 方法，调用了外部类ThreadPoolExecutor的 runWorker 方法，这个方法是让每个线程去执行一个while循环，在这个循环代码中，去判断是否有任务待执行，若有则直接去执行这个任务，因此线程数不会增加。

源码解析

线程池的任务提交从 submit 方法来说，submit 方法是 AbstractExecutorService 抽象类定义的，主要做了两件事情：
把 Runnable 和 Callable 都转化成 FutureTask
使用 execute 方法执行 FutureTask
execute 方法是 ThreadPoolExecutor 中的方法，源码如下：

public void execute(Runnable command) {
    // 若任务为空，则抛 NPE，不能执行空任务
    if (command == null) {
        throw new NullPointerException();
    }
    int c = ctl.get();
    // 若工作线程数小于核心线程数，则创建新的线程，并把当前任务 command 作为这个线程的第一个任务
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true)) {
            return;
        }
        c = ctl.get();
    }
    /**
        * 至此，有以下两种情况：
        * 1.当前工作线程数大于等于核心线程数
        * 2.新建线程失败
        * 此时会尝试将任务添加到阻塞队列 workQueue
        */
    // 若线程池处于 RUNNING 状态，将任务添加到阻塞队列 workQueue 中
    if (isRunning(c) && workQueue.offer(command)) {
        // 再次检查线程池标记
        int recheck = ctl.get();
        // 如果线程池已不处于 RUNNING 状态，那么移除已入队的任务，并且执行拒绝策略
        if (!isRunning(recheck) && remove(command)) {
            // 任务添加到阻塞队列失败，执行拒绝策略
            reject(command);
        }
        // 如果线程池还是 RUNNING 的，并且线程数为 0，那么开启新的线程
        else if (workerCountOf(recheck) == 0) {
            addWorker(null, false);
        }
    }
    /**
        * 至此，有以下两种情况：
        * 1.线程池处于非运行状态，线程池不再接受新的线程
        * 2.线程处于运行状态，但是阻塞队列已满，无法加入到阻塞队列
        * 此时会尝试以最大线程数为界创建新的工作线程
        */
    else if (!addWorker(command, false)) {
        // 任务进入线程池失败，执行拒绝策略
        reject(command);
    }
}

可以看到 execute 方法中的的核心方法为 addWorker，再去看 addWorker 方法之前，先看下 Worker 的初始化方法：

Worker(Runnable firstTask) {
    // 每个任务的锁状态初始化为-1，这样工作线程在运行之前禁止中断
    setState(-1);
    this.firstTask = firstTask;
    // 把 Worker 作为 thread 运行的任务
    this.thread = getThreadFactory().newThread(this);
}

在 Worker 初始化时创建线程把当前 Worker 作为构造器线程参数，接下来从 addWorker 方法中可以找到如下代码：

final Thread t = w.thread;
// 如果成功添加了 Worker，就可以启动 Worker 了
if (workerAdded) {
    t.start();
    workerStarted = true;
}

这块代码是添加 worker 成功，调用 start 方法启动线程，Thread t = w.thread; 此时的 w 是 Worker 的引用，那么t.start();实际上执行的就是 Worker 的 run 方法。
Worker 的 run 方法中调用了外部类ThreadPoolExecutor的 runWorker 方法，简化后的 runWorker 源码如下：

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

可以看出，实现线程复用的逻辑主要在一个不停循环的 while 循环体中。
通过取 Worker 的 firstTask 或者通过 getTask 方法从 workQueue 中获取待执行的任务。
直接调用 task 的 run 方法来执行具体的任务（而不是新建线程）。
getTask 的主要作用是阻塞从队列中拿任务出来，如果队列中有任务，那么就可以拿出来执行，如果队列中没有任务，这个线程会一直阻塞到有任务为止（或者超时阻塞）。这样就保证了每个线程都始终在一个循环中，反复获取任务，然后执行任务，从而实现了线程的复用。

Runnabler = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take();

getTask()里有上面这行关键代码

如果当前线程数大于corePoolSize，则调用workQueue的poll（非阻塞）获取task，超时时间是keepAliveTime。如果超时，poll返回null，while循环退出，非核心线程就执行完了。
如果当前线程数小于等于corePoolSize，就会调用workQueue的take（阻塞）获取task，则这个线程就会阻塞住等待task到来。

四、线程池的创建

创建线程池主要是ThreadPoolExecutor类来完成，ThreadPoolExecutor 的有许多重载的构造方法，通过参数最多的构造方法来理解创建线程池有哪些需要配置的参数。ThreadPoolExecutor 的构造方法为：

ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

下面对参数进行说明：

corePoolSize：表示核心线程池的大小。当提交一个任务时，如果当前核心线程池的线程个数没有达到 corePoolSize，则会创建新的线程来执行所提交的任务，即使当前核心线程池有空闲的线程。如果当前核心线程池的线程个数已经达到了 corePoolSize，则不再重新创建线程。如果调用了prestartCoreThread()或者 prestartAllCoreThreads()，线程池创建的时候所有的核心线程都会被创建并且启动。
maximumPoolSize：表示线程池能创建线程的最大个数。如果当阻塞队列已满时，并且当前线程池线程个数没有超过 maximumPoolSize 的话，就会创建新的线程来执行任务。
keepAliveTime：空闲线程存活时间。如果当前线程池的线程个数已经超过了 corePoolSize，并且线程空闲时间超过了 keepAliveTime 的话，就会将这些空闲线程销毁，这样可以尽可能降低系统资源消耗。
unit：时间单位。为 keepAliveTime 指定时间单位。
workQueue：阻塞队列。用于保存任务的阻塞队列。可以使用ArrayBlockingQueue, LinkedBlockingQueue, SynchronousQueue, PriorityBlockingQueue。
阻塞队列可以保证任务队列中没有任务时阻塞获取任务的线程，使得线程进入wait状态，释放cpu资源。
当队列中有任务时才唤醒对应线程从队列中取出消息进行执行。
使得在线程不至于一直占用cpu资源。
threadFactory：创建线程的工程类。可以通过指定线程工厂为每个创建出来的线程设置更有意义的名字，如果出现并发问题，也方便查找问题原因。
handler：饱和策略。当线程池的阻塞队列已满和指定的线程都已经开启，说明当前线程池已经处于饱和状态了，那么就需要采用一种策略来处理这种情况。采用的策略有这几种：
- AbortPolicy：直接拒绝所提交的任务，并抛出RejectedExecutionException异常；
- CallerRunsPolicy：只用调用者所在的线程来执行任务；
- DiscardPolicy：不处理直接丢弃掉任务；
- DiscardOldestPolicy：丢弃掉阻塞队列中存放时间最久的任务，执行当前任务

五、线程池的关闭

关闭线程池，可以通过shutdown和shutdownNow这两个方法。它们的原理都是遍历线程池中所有的线程，然后依次中断线程。shutdown和shutdownNow还是有不一样的地方：

shutdownNow首先将线程池的状态设置为STOP,然后尝试停止所有的正在执行和未执行任务的线程，并返回等待执行任务的列表；
shutdown只是将线程池的状态设置为SHUTDOWN状态，然后中断所有没有正在执行任务的线程
可以看出 shutdown 方法会将正在执行的任务继续执行完，而 shutdownNow 会直接中断正在执行的任务。调用了这两个方法的任意一个，isShutdown方法都会返回 true，当所有的线程都关闭成功，才表示线程池成功关闭，这时调用isTerminated方法才会返回 true。

六、如何合理配置线程池参数

要想合理的配置线程池，就必须首先分析任务特性，可以从以下几个角度来进行分析：

任务的性质：CPU 密集型任务，IO 密集型任务和混合型任务。
任务的优先级：高，中和低。
任务的执行时间：长，中和短。
任务的依赖性：是否依赖其他系统资源，如数据库连接。

任务性质不同的任务可以用不同规模的线程池分开处理。
CPU 密集型任务配置尽可能少的线程数量，如配置Ncpu+1个线程的线程池。因为CPU密集型任务使得CPU使用率很高，若开过多的线程数，会造成CPU过度切换。
IO 密集型任务则由于需要等待 IO 操作，线程并不是一直在执行任务，则配置尽可能多的线程，如2xNcpu。IO密集型任务CPU使用率并不高，因此可以让CPU在等待IO的时候有其他线程去处理别的任务，充分利用CPU时间。
混合型的任务，如果可以拆分，则将其拆分成一个 CPU 密集型任务和一个 IO 密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐率要高于串行执行的吞吐率，如果这两个任务执行时间相差太大，则没必要进行分解。我们可以通过Runtime.getRuntime().availableProcessors()方法获得当前设备的 CPU 个数。

优先级不同的任务可以使用优先级队列 PriorityBlockingQueue 来处理。它可以让优先级高的任务先得到执行，需要注意的是如果一直有优先级高的任务提交到队列里，那么优先级低的任务可能永远不能执行。

执行时间不同的任务可以交给不同规模的线程池来处理，或者也可以使用优先级队列，让执行时间短的任务先执行。

依赖数据库连接池的任务，因为线程提交 SQL 后需要等待数据库返回结果，如果等待的时间越长 CPU 空闲时间就越长，那么线程数应该设置越大，这样才能更好的利用 CPU。

Chary Liu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java线程池原理

一、线程池简介1.1 为什么要使用线程池在实际使用中，线程的创建与销毁都是很占用系统资源的，因为java线程依赖于内核线程，创建线程需要操作系统状态切换，如果对线程管理不善很容易导致系统问题。因此，在大多数并发框架中都会使用线程池来负责对线程进行统一分配、调优与监控，使用线程池管理线程主要有如下好处：降低资源消耗。通过复用已存在的线程和降低线程关闭的次数来尽可能降低系统性能损耗；提升系统响应速度。通过复用线程，省去创建线程的过程，因此整体上提升了系统的响应速度；提高线程的可管理性。线程是稀缺资源
复制链接

扫一扫