Java线程池原理解析

最新推荐文章于 2023-05-19 10:35:38 发布

ruiurrui

最新推荐文章于 2023-05-19 10:35:38 发布

阅读量332

点赞数

分类专栏： Android 文章标签：线程池原理解析线程池源码解析

本文链接：https://blog.csdn.net/u010982507/article/details/112876480

版权

线程的消耗

1、其实 Java 中的线程模型是基于操作系统原生线程模型实现的，也就是说 Java 中的线程其实是基于内核线程实现的，线程的创建，析构与同步都需要进行系统调用，而系统调用需要在用户态与内核中来回切换，代价相对较高，线程的生命周期耗时包括「线程创建时间」,「线程执行任务时间」,「线程销毁时间」，创建和销毁都需要导致系统调用；

2、每个 Thread 都需要有一个内核线程的支持，也就意味着每个 Thread 都需要消耗一定的内核资源（如内核线程的栈空间），因此能创建的 Thread 是有限的；

3、线程多了，导致不可忽视的上下文切换开销。

由此可见线程的创建消耗代价是昂贵的，所以必须以线程池的形式来管理这些线程，在线程池中合理设置线程大小和管理线程，以达到以合理的创建线程大小以达到最大化收益，最小化风险的目的，对于开发人员来说，要完成任务不用关心线程如何创建，如何销毁，如何协作，只需要关心提交的任务何时完成即可，对线程的调优，监控等这些细枝末节的工作通通交给线程池来实现。

线程池类关系

先来看一张线程池的继承类关系图：
在这里插入图片描述

最顶层的是Executor接口，源码里只有execute一个声明方法；
Executor接口的子类是ExecutorService接口，源码中声明了shutdown、shutdownNow、isShutdown、submit等方法；
Executor接口有两个子类，一个是AbstractExecutorService抽象类，一个是ScheduledExecutorService接口；
AbstractExecutorService抽象类是ThreadPoolExecutor类和ForkJoinPool类的父类；
ScheduledExecutorService接口的实现类是ScheduledThreadPoolExecutor，ScheduledThreadPoolExecutor类又是ThreadPoolExecutor类的子类；
最后就是上一篇中所说的6种线程池的创建方式和ThreadPoolExecutor创建方式。

线程池工作原理

线程池运行机制主要由工作线程、工作队列、拒绝策略组成，其工作原理如下所示：

如果此时线程池中的线程数量小于corePoolSize，无论线程池中的线程是否处于空闲状态，也会创建新的线程来处理被添加的任务；
如果此时线程池中的线程数量等于corePoolSize，但是阻塞队列workQueue未满，那么任务被放入阻塞队列；
如果此时线程池中的线程数量大于等于corePoolSize，阻塞队列workQueue已满，并且线程池中的线程数量小于maximumPoolSize，则会创建新的线程来处理被添加的任务；
如果此时线程池中的线程数量大于corePoolSize，阻塞队列workQueue已满，并且线程池中的线程数量等于maximumPoolSize，那么通过 handler所指定的拒绝策略来处理此任务；
当线程池中的线程数量比corePoolSize数量要多时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。

从线程池工作原理中可以得知：

提交任务优先级为核心线程corePoolSize > 任务队列workQueue> 最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务；
当workQueue使用的是无界限队列时(比如new LinkedBlockingQueue(),或者new ArrayBlockingQueue(Integer.MAX_VALUE)；)，任务可以一直向队列中添加，maximumPoolSize参数就变的无意义了。比如newFixedThreadPool和newSingleThreadExecutor这两种线程池的工作队列是LinkedBlockingQueue，而maximumPoolSize和corePoolSize相等。
使用SynchronousQueue队列时由于该队列没有容量的特性（特点：内部没有容器，一个生产线程，当它生产产品（即put的时候），如果当前没有人想要消费产品(即当前没有线程执行take)，此生产线程必须阻塞，等待一个消费线程调用take操作，take操作将会唤醒该生产线程，同时消费线程会获取生产线程的产品，队列操作时offer为非阻塞，take为阻塞，put也为阻塞操作），所以不会对任务进行排队，如果线程池中没有空闲线程，会立即创建一个新线程来接收这个任务，故而maximumPoolSize要设置大一点；

比如：newCachedThreadPool中使用的是SynchronousQueue，任务到来，有空闲线程则使用空闲线程，无空闲线程则创建。所以称之为缓存线程，而它的maximumPoolSize设置的是Integer.MAX_VALUE；
核心线程和最大线程数量相等时keepAliveTime无作用，因为只有当前运行线程数大于corePoolSize时，才会判断当有空闲线程时并且到了keepAliveTime的时间，终止线程。
线程池能处理的任务数 = corePoolSize + 阻塞队列容量 + 创建的工作线程（maximumPoolSize - corePoolSize ），比如corePoolSize 为2，阻塞队列为5，maximumPoolSize 为10，当前要创建的线程为16，则corePoolSize 先运行2个核心线程，剩下的放入阻塞队列5个，然后再创建(10-2)8个工作线程，总共运行线程是 2 + 5+ 8 = 15，剩下最后一个线程则由拒绝策略处理。

线程池源码解析

《线程池的使用方式》一文中了解了线程池的创建方式，这里开始分析线程池的执行方法execute：

public void execute(Runnable command) {
    ......
    // 1.获取线程运行状态或数量
    int c = ctl.get();
    // 2.如果线程池线程数量小于核心线程数，则创建新线程
     if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
    // 3、如果线程数量大于等于corePoolSize，并且
    // 如果线程池是运行状态，则将线程添加到工作队列
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 4、再次检测线程是否是运行状态，因为执行入队操作后，线程有可能不是运行状态了
        // 如果线程池不在运行状态，则移除线程，并执行拒绝策略
        if (! isRunning(recheck) && remove(command))
            reject(command);
        // 5、如果线程是运行状态，线程数量是0，则开启新线程
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 6、如果添加worker失败，则执行拒绝策略
    else if (!addWorker(command, false))
        reject(command);
}

1、获取线程运行状态或数量；

2、判断工作线程数量如果小于核心线程，则开启核心线程，第二个参数传true表示是不是核心线程；

private boolean addWorker(Runnable firstTask, boolean core)

3、如果线程数量大于等于corePoolSize，并且如果线程池是运行状态，则将线程添加到工作队列；这里有必须了解一下线程池的几种状态：

线程池状态管理

通过下面源码得知，线程池使用AtomicInteger类型（AtomicInteger是一个提供原子操作的Integer类，通过线程安全的方式操作加减，十分适合高并发情况下的使用）的ctl变量记录线程池的状态和线程池中的线程数量，初始化的时候传入ctlOf(RUNNING, 0)的执行结果，通过函数可以发现返回RUNNING的值，即111 00000000000000000000000000000，这里有32位，低 29 位表示线程数量， 29 位最大可以表示 (2^29)-1 (536870911)个线程数，，高 3 位用来表示线程池的状态，3 位可以表示 8 个线程池的状态，而线程池总共只有五个状态。

public class ThreadPoolExecutor extends AbstractExecutorService {
   
    // ctl用了记录线程池的状态和线程池中的线程数量
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    // 32 - 3 = 29
    private static final int COUNT_BITS = Integer.SIZE - 3;
    // 表示29左移1位，再减1，容量是1 1111 1111 1111 1111 1111 1111 1111，十进制是 2^29-1 = 536870911
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // RUNNING，-1左移29位 111 00000000000000000000000000000  29个0
    private static final int RUNNING    = -1 << COUNT_BITS;
    // SHUTDOWN，0左移29位，000 00000000000000000000000000000
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    // STOP，1左移29位 001 00000000000000000000000000000
    private static final int STOP       =  1 << COUNT_BITS;
    // TIDYING, 2左移29位 010 00000000000000000000000000000
    private static final int TIDYING    =  2 << COUNT_BITS;
    // TERMINATED，3左移29位 011 00000000000000000000000000000
    private static final int TERMINATED =  3 << COUNT_BITS;
    // 线程状态
    private static int runStateOf(int c)     {
    return c & ~CAPACITY; }
    // 线程数量
    private static int workerCountOf(int c)  {
    return c & CAPACITY; }
    // 初始化ctl
    private static int ctlOf(int rs, int wc) {
    return rs | wc; }

移位运算符

<< : 左移运算符，num << n, 相当于num左移n位;

>> : 右移运算符，num >> n, 相当于num右移n位;

可以测试一下输出：

// 测试
int COUNT_BITS = Integer.SIZE - 3; // 32 - 3 = 29
Log.e(TAG, "COUNT_BITS: " + COUNT_BITS);
Log.e(TAG, "COUNT_BITS toBinaryString: " + Integer.toBinaryString(COUNT_BITS));
int CAPACITY = (1 << COUNT_BITS) - 1; // 1左移29位再减1，11111111111111111111111111111
Log.e(TAG, "CAPACITY: " + CAPACITY);
Log.e(TAG, "CAPACITY: " + Integer.toBinaryString(CAPACITY));
int RUNNING = -1 << COUNT_BITS; // -1左移29位 111 0 0000 0000 0000 0000 0000 0000 0000
Log.e(TAG, "RUNNING: " + Integer.toBinaryString(RUNNING));
int SHUTDOWN = 0 << COUNT_BITS; // 0 左移29位 000 0 0000 0000 0000 0000 0000 0000 0000
Log.e(TAG, "SHUTDOWN: " + Integer.toBinaryString(SHUTDOWN));
int STOP = 1 << COUNT_BITS; // 1左移29位 001 0 0000 0000 0000 0000 0000 0000 0000
Log.e(TAG, "STOP: " + Integer.toBinaryString(STOP));
int TIDYING = 2 << COUNT_BITS; // 2左移29位 010 0 0000 0000 0000 0000 0000 0000 0000
Log.e(TAG, "TIDYING: " + Integer.toBinaryString(TIDYING));
int TERMINATED = 3 << COUNT_BITS; // 3左移29位 011 0 0000 0000 0000 0000 0000 0000 0000
Log.e(TAG, "TERMINATED: " + Integer.toBinaryString(TERMINATED));

线程池状态

RUNNING：接受新任务并且处理阻塞队列里的任务；
SHUTDOWN：拒绝新任务但是处理阻塞队列里的任务；
STOP：拒绝新任务并且抛弃阻塞队列里的任务，同时会中断正在处理的任务；
TIDYING：所有任务都执行完（包含阻塞队列里面任务）当前线程池活动线程为 0，将要调用 terminated 方法；
TERMINATED：终止状态，terminated方法调用完成以后的状态。

线程池状态转换

1.RUNNING -> SHUTDOWN：显式调用 shutdown() 方法，或者隐式调用了 finalize()，它里面调用了 shutdown() 方法。

2.RUNNING or SHUTDOWN -> STOP：显式调用 shutdownNow() 方法时候。

3.SHUTDOWN -> TIDYING：当线程池和任务队列都为空的时候。

4.STOP -> TIDYING：当线程池为空的时候。

5.TIDYING -> TERMINATED：当 terminated() 方法执行完成时候。

4、再次检测线程是否是运行状态，因为执行入队操作后，线程有可能不是运行状态了，如果线程池不在运行状态，则移除线程，并执行拒绝策略；

5、如果线程是运行状态，线程数量是0，则开启新线程；

6、如果添加worker失败，则执行拒绝策略，拒绝策略实际调用了RejectedExecutionHandler的rejectedExecution方法：

final void reject(Runnable command) {
   
    handler.rejectedExecution(command, this);
}

其实execute方法中最主要的是addWorker方法，下面分析一下Worker的处理流程：

线程池中的Worker

线程池为了掌握线程的状态并维护线程的生命周期，设计了线程池内的工作线程Worker。Worker首先继承了AbstractQueuedSynchronizer父类（Java并发编程核心在于 java.concurrent.util 包而juc当中的大多数同步器实现都是围绕着共同的基础行为，比如等待队列、条件队列、独占获取、共享获取等，而这个行为的抽象就是基于 AbstractQueuedSynchronizer 简称AQS，AQS定义了一套多线程访问共享资源的同步器框架，是一个依赖状态(state)的同步器。子类们必须定义改变state变量的protected方法，这些方法定义了state是如何被获取或释放的），并实现了Runnable接口，实现了Runnable接口。

// 此处可以看出 worker 既是一个 Runnable 任务，也实现了 AQS（实际上是用 AQS 实现了一个独占锁，这样由于 worker 运行时会上锁，执行 shutdown，setCorePoolSize，setMaximumPoolSize等方法时会试着中断线程（interruptIdleWorkers） ，在这个方法中断方法中会先尝试获取 worker 的锁，如果不成功，说明 worker 在运行中，此时会先让 worker 执行完任务再关闭 worker 的线程，实现优雅关闭线程的目的）
private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
    {
   
        private static final long serialVersionUID = 6138294804551838833L;

        // 实际执行任务的线程
        final Thread thread;
        // 如果当前线程数少于核心线程数，创建线程并将提交的任务交给 worker处理，此时 firstTask 即为此提交的任务，如果 worker 从 workQueue 中获取任务，则 firstTask 为空
        Runnable firstTask;
        // 统计完成的任务数
        volatile long completedTasks;

        Worker(Runnable firstTask) {
   
            // 初始化为 -1，这样在线程运行前（调用runWorker）禁止中断，在 interruptIfStarted() 方法中会判断 getState()>=0
            setState(-1); 
            this.firstTask = firstTask;

            // 根据线程池的 threadFactory 创建一个线程，将 worker 本身传给线程（因为 worker 实现了 Runnable 接口）
            this.thread = getThreadFactory().newThread(this);
        }

        public void run() {
   
            // thread 启动后会调用此方法
            runWorker(this);
        }

       
        // 1 代表被锁住了，0 代表未锁
        protected boolean isHeldExclusively() {
   
            return getState() != 0;
        }

        // 尝试获取锁
        protected boolean tryAcquire(int unused) {
   
            // 从这里可以看出它是一个独占锁，因为当获取锁后，cas 设置 state 不可能成功，这里我们也能明白上文中将 state 设置为 -1 的作用，这种情况下永远不可能获取得锁，而 worker 要被中断首先必须获取锁
            if (compareAndSetState(0, 1)) {
   
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        // 尝试释放锁
        protected boolean tryRelease(int unused) {
   
            setExclusiveOwnerThread(null

最低0.47元/天解锁文章

ruiurrui

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java线程池原理解析

线程的消耗1、其实 Java 中的线程模型是基于操作系统原生线程模型实现的，也就是说 Java 中的线程其实是基于内核线程实现的，线程的创建，析构与同步都需要进行系统调用，而系统调用需要在用户态与内核中来回切换，代价相对较高，线程的生命周期耗时包括「线程创建时间」,「线程执行任务时间」,「线程销毁时间」，创建和销毁都需要导致系统调用；2、每个 Thread 都需要有一个内核线程的支持，也就意味着每个 Thread 都需要消耗一定的内核资源（如内核线程的栈空间），因此能创建的 Thread 是有限的；3
复制链接

扫一扫