九、详解线程池ThreadPool

每天都得进步

已于 2023-12-25 22:22:11 修改

阅读量864

点赞数 15

分类专栏：并发编程文章标签： java 开发语言

于 2023-12-25 17:22:43 首次发布

本文链接：https://blog.csdn.net/2301_77203215/article/details/135195236

版权

并发编程专栏收录该内容

10 篇文章 0 订阅

订阅专栏

核心模型

有图可知，线程池的核心组成部分分别为：线程列表和阻塞队列。

1、线程列表：这个很容易理解，就是一堆线程，用一个列表存储起来。每次都复用列表中的线程来执行任务，而不需要重新创建新的线程。

2、阻塞队列：为什么需要一个阻塞队列呢，普通的队列行不行呢？之所以阻塞队列，主要的原因是平衡【放任务】和【拿任务】之间的速率。

如果【放任务】的速度快，但是【拿任务】的速度慢，那么就需要一个队列来存储多余的任务。

如果【拿任务】的速度快，但是【放任务】的速度慢，那么就需要线程等待新的任务，因此就需要一个阻塞的地方，让线程等待。

因此通过对上述两点的分析，需要的是一个有阻塞功能的队列，BlockingQueue。

模型分析

下面对上述的模型进行分析：

1、阻塞队列：在线程池中，阻塞队列都需要什么属性，需要什么功能呢？

首先，需要一个list来存储相应的任务对象。

第二，需要存储一把锁，因为【放任务】和【拿任务】可能有多个线程在同时执行

第三，需要等待条件，【放任务】的线程等待【队列非满】，而【拿任务】的线程等待【队列非空】

第四，需要一个get任务的方法，和一个put任务的方法。这个两个方法应该是互斥加锁的，并且在不同的条件下等待。详细可参考：五、详解ReentrantLock-CSDN博客

2、线程列表：线程列表就是一个list类型，每个元素就是一个线程。当然为了做一下特殊逻辑，可以用Thread的父类来进行封装。二、线程创建与运行-CSDN博客

上述的模型为线程池的核心模型，在真正生产环境中，需要根据不同的需求在核心模型的基础上增加其他的功能，例如核心线程数，最大线程数，最大队列长度，等待时间，拒绝策略，线程工厂等等。

那么下面我们开始介绍在生产环境中，真正使用的几种线程池。

ThreadPoolExecutor源码分析

线程池状态

在具体讲解源码之前，先介绍一下ThreadPoolExecutor中的ctl变量。ctl是一个原子整数（AtomicInteger），它同时包含了线程池的运行状态和线程池中工作线程的数量。

其高三位为当前线程池的状态，低29位为当前线程池中的线程数。在TheadPoolExecutor中调用ctlOf方法将状态和个数拼接起来。

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

那么为什么ThreadPoolExecutor要用一个int变量来表示两个概念，而不是用两个int变量来分别表示线程池状态和线程个数呢？

其主要原因为了并发考虑，因为线程池状态和线程数量在一个int中，只需要一次cas就能将两个含义同时原子的更新。如果用两个变量，需要保证两个变量的一致性。

下面分析一下整个线程池的状态，线程池的状态分为一下几种：

running : 当线程池处于running状态的时候，用户可以向线程池中添加新任务，并且线程正常处理阻塞队列中的任务。

shutdown：当线程处于shutdown状态的时候，用户不能像线程池中添加新的任务了，但是线程依然能够将队列中的任务执行完毕

stop：当线程处于stop状态的时候，用户无法向线程池提交新的任务，并且线程也不会继续执行队列中的任务。

构造方法

先从创建一个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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
}

1、corePoolSize:核心线程数，意味着当正常情况下，线程池只有corePoolSize个线程在运行

2、maximumPoolSize: 最大线程数，可以理解为救急线程，当线程池中的线程数已经等于corePoolSize，并且阻塞队列中已经满足，那么就继续扩容线程，直到线程数为maximumPoolSize

3、keepAliveTime: 表示那些创建的救急线程需要空转多长时间，如果超过这个时间，救急线程将被回收

4、TImeUnit：时间单位

5、workQueue：阻塞队列。请看核心模型

5、threadFactory：创建线程的工厂，如果不设置，将会分配一个默认的工DefaultThreadFactory

6、handler：拒绝策略。当核心线程数满了，阻塞队列满足，救急线程也满了，那么当前put任务的线程要执行这个handler，来确认如何处理。

常见的拒绝策略有：AbortPolicy，CallerRunsPolicy，DiscardOldestPolicy， DiscardPolicy。后面详细分析一下上述四个拒绝策略的代码。

execute()方法

该方法用于提交一个可执行的任务，这个是我们在生产环境最常用的一个方法之一。接下来具体分析线程池是如何执行的。

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        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);
}

1、首先从ctl原子变量中获取值，然后通过workerCountof函数从ctl中获取低29位，计算出线程数。我们之前讲过ctl高三位记录线程池状态，低29位记录线程个数。

private static int workerCountOf(int c)  { 
    return c & COUNT_MASK; 
}

private static final int COUNT_MASK = (1 << COUNT_BITS) - 1;


private static final int COUNT_BITS = Integer.SIZE - 3;

上述代码COUNT_BITS = Integer.SIZE-3。 Integer.SIZE表示Integer类型的大小，即占用几个bit位，所以COUNT_BITS=32-3 = 29。

COUNT_MASK = (1<<29)-1，即将数字1左移29位，即10000000000（后面29个0），然后再-1，那就是29个1。

因此workerCountOf（c）方法的逻辑就是将c与29个1向&操作，结果就是后29bit的值。

addWorker()

2、之后判断当前线程数是否小于corePoolSize。如果小于，那么执行addWork方法。如果addWorker添加成功，则直接返回，否则，执行下一个if

我们重点分析addWork方法，这个方法的意思是，添加一个worker，其实本质上就是添加一个线程。

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (int c = ctl.get();;) {
            // Check if queue empty only if necessary.
            if (runStateAtLeast(c, SHUTDOWN)
                && (runStateAtLeast(c, STOP)
                    || firstTask != null
                    || workQueue.isEmpty()))
                return false;

            for (;;) {
                if (workerCountOf(c)
                    >= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
                    return false;
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateAtLeast(c, SHUTDOWN))
                    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 {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int c = ctl.get();

                    if (isRunning(c) ||
                        (runStateLessThan(c, STOP) && 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;
    }

这段代码的主要逻辑：

1、先判断线程池的状态，如果是ShutDown或者是Stop则直接添加失败。这个我们之前讲过。

2、然后再次判断当前线程的个数是否已经到达了核心线程数，如果到达了，则直接添加失败

3、之后将线程数利用cas的方式进行加1。八、详解CAS无锁-CSDN博客

4、如果上述都满足，则执行new Worker（firstTask）。这段代码就是创建一个线程池。我们看一下worker的源码

Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
}

可以看到，Worker的构造函数中，将当前提交的runnable任务复制给firstTask，然后创建了一个线程。并将this复制给线程，因此我们可以推断，Worker类一定实现了Runnable接口，然后创建的这个线程调用start方法的时候，一定运行了Worker的run方法。也就是说线程池中的线程运行逻辑其实就是Worker的run。

worker的run()方法

那么我们看一下worker的run方法，这个是核心

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            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);
                    try {
                        task.run();
                        afterExecute(task, null);
                    } catch (Throwable ex) {
                        afterExecute(task, ex);
                        throw ex;
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

这段代码，就是线程池中每个线程真正执行的逻辑：

1、第一步就进入一个while循环，判断firstTask是否为空，如果firstTask不为空，则进行循环体，如果为空，则执行getTask(). 这个方法我们一会讲，这个方法里面涉及到了救急线程是如何销毁的。

2、当task不为空的时候，进入循环体，如果为空，调用finaly，然后当前线程结束。这个finnaly里面的逻辑就是将当前worker从workers队列中删除，因为线程销毁了，worker对象也没用用了。然后尝试终止线程池，如果线程池已经没有工作线程，则不在接收新的任务。

3、如果task不为空，也就是能获取到runnable任务，那么就执行runnable的run方法。当执行完之后，将task赋值为null，之后在此进行while循环，从新获取任务，周而复始。

getTask()方法

接下来看一下worker中，是如何getTask()的

private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        for (;;) {
            int c = ctl.get();//获取线程池ctl

            // Check if queue empty only if necessary.
            if (runStateAtLeast(c, SHUTDOWN)
                && (runStateAtLeast(c, STOP) || workQueue.isEmpty())) {
                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 {
            //如果线程池超了，那么就利用超时等待的方式区poll，否则就用阻塞的方式。
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true; 
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
}

getTask()的核心逻辑就是判断当前线程池中的线程是否大于核心线程数，或者配置核心线程数可销毁。如果是线程数超过了核心线程数，那么本次线程去队列获取任务的时候，就利用等待超时（这里就用到了keeplivetime），如果没有超过，那么就一直阻塞线程，直到有新的任务被添加到队列。

当addWorker执行完之后，将新的worker加入到worker队列中，也就是核心模型中的线程list中。当然这个步骤是加了lock锁的。之后调用worker的start方法，开始执行逻辑。

下面我们回到execute()方法，如果addWorker()失败，那么就向阻塞队列中插入一个任务。

这里用到了阻塞队里的 queue.offer()方法。这里大概看一下阻塞队列是如何工作的，其实就是利用了lock锁和condition。五、详解ReentrantLock-CSDN博客

以LinkedBlockingDeque为例：

public boolean offerLast(E e) {
        if (e == null) throw new NullPointerException();
        Node<E> node = new Node<E>(e); //创建一个node节点
        final ReentrantLock lock = this.lock;
        lock.lock(); //加锁
        try {
            return linkLast(node); //添加元素
        } finally {
            lock.unlock(); //解锁
        } 
    }

而的关键在于linkLast()方法：

 private boolean linkLast(Node<E> node) {
        // assert lock.isHeldByCurrentThread();
        if (count >= capacity) //超过容量，直接失败
            return false;
        Node<E> l = last; //获取尾节点
        node.prev = l;
        last = node;
        if (first == null)
            first = node;
        else
            l.next = node;
        ++count;
        notEmpty.signal(); //释放不为空的信号
        return true;
}

这里可以看到，当向队列加入元素的时候不会阻塞，如果超过容量则直接返回false。只有从队列拿数据的时候才会阻塞。

继续回到execute()方法，当添加队列失败了，那么就继续判断是否超过核心线程数，如果没有，则创建救急线程。

最后，如果救急线程创建失败，则执行reject方法

reject()方法

这个就是在调用拒绝策略：

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

其实就是调用一开始构造方法里面传递过来的RejectHandler。

接下来分析一下jdk提供的四种拒绝策略：
1、AbortPolicy：直接抛出异常

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }

2、CallerRunsPolicy：当前调用线程执行runnable任务。

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run(); //当前线程直接调用run
            } 
}

3、DiscardPolicy：直接丢弃任务

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        //空的方法体，直接忽略这个任务
}

4、DiscardOldestPolicy：丢弃最早添加的那个任务

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll(); //丢弃队列的头
                e.execute(r); //重新提交改任务
            }
}

每天都得进步

关注

15
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
九、详解线程池ThreadPool

有图可知，线程池的核心组成部分分别为：线程列表和阻塞队列。1、线程列表：这个很容易理解，就是一堆线程，用一个列表存储起来。每次都复用列表中的线程来执行任务，而不需要重新创建新的线程。2、阻塞队列：为什么需要一个阻塞队列呢，普通的队列行不行呢？之所以阻塞队列，主要的原因是平衡【放任务】和【拿任务】之间的速率。如果【放任务】的速度快，但是【拿任务】的速度慢，那么就需要一个队列来存储多余的任务。
复制链接

扫一扫