从0了解线程池，教你讲哭面试官。

爱蛋蛋真是太好了

于 2022-04-07 16:19:16 发布

阅读量138

点赞数

分类专栏：并发文章标签： java

本文链接：https://blog.csdn.net/qq_37827889/article/details/123276825

版权

并发专栏收录该内容

5 篇文章 0 订阅

订阅专栏

zh@TOC

线程池作用

很多同学在工作中使用线程池的场景并不多，所以对线程池的了解也不多。但在面试中，线程池的面试比重还是挺大的。在这里我给大家讲下我对线程池的理解。
1.线程池可以复用线程，减少重复创建线程的消耗。大家应该知道线程的创建和销毁，在任务耗时不大的时候，会大量占用CPU和消耗性能。如果这时候使用线程池的话，能有效的复用线程，减少不必要的损耗。
2.线程池功能强大，有着比较完整的线程管理以及强大API，让你对线程的执行有着一定控制度，并可以减少你一定的开发量。这上面可能是我对线程池的作用比较了解的方法了

线程池结构

看图片可以知道可以大致了解下线程池的层级结构，大概看下就行，记住层级结构，可能面试会问。

线程池核心参数

在使用线程池的时候避不开他其中的七大参数，我们一一了解下他们的用处和含义。

corePoolSize：核心线程数，理解就是线程可以一直保留在线程池的最大线程数。(也可以通俗的理解为正式员工)

maximumPoolSize：最大线程数，池中允许的最大线程数。

keepAliveTime：当池中线程数大于核心线程数，此时，大于核心数的临时线程数等待新任务最大的等待时间。（临时线程数可以理解为外包… 哈哈）

unit：keepAliveTime的时间单位

workQueue：用于保存执行任务之前保存任务的队列，此队列仅保存由execute提交的任务。

threadFactory：执行器创建新线程时使用的工厂。

handler：用于在线程池和队列都满的情况，执行对后续任务的处理器。（通俗叫拒绝策略，但在现实中大部分都是要自我处理的）

以上就是创建线程池需要的七大参数了，我们了解以后继续往下看，我们不讲啥废话，直接上干货。讲解下线程池的核心方法

核心方法一、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);
    }

这个代码看上去虽然短，但其中包含很多的逻辑，我们就一些难理解的方法一一讲解下。

workerCountOf

这个是我看源码的时候第一个懵的地方，后面仔细研究就搞明白了,首先我们看下在线程池中的几个常量：

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

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

讲到这几个常量就顺便把线程池的运行状态也讲一下：
RUNNING ：表示线程池可以接收新的任务并可以处理队列中的任务。
SHUTDOWN ：表示不接受新的任务，但可以处理队列中的任务。
STOP ：不接受新任务，不处理排队的任务，中断正在进行的任务
TIDYING ：所有任务都已终止，workerCount 为零，转换到状态 TIDYING 的线程将运行 terminate() 钩子方法
TERMINATED ：terminate() 钩子方法已经完成。

开发者这里很巧妙的把Int类型数据分成两部分，高三位记录线程池的运行状态，低29位用来记录在线程池中运行的线程池数量。这样可以更快更简单的去记录线程池的状态和运行数量。

上面我把这些参数变成二进制，然后再看下workerCountOf的实现

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

这里就是纯粹的位运算了（我们以第一次线程进入时，此时的情况为例）

11100000 00000000 00000000 00000000
&
00011111 11111111 11111111 11111111
有位运算知识的都知道。

这样结果应该为0

这样讲大概应该能清楚这个方法的道理了把？我就大概讲下。

大家有疑问可以评论沟通。

addWorker

这个方法也是比较重要的，在线程池的API中多次被调用，我们也来讲解下，对这个里面一些展开的方法我就不细讲了，根据我之前博客的经验这样会大量分散大家的注意力。

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

            // Check if queue empty only if necessary.
            // 如果 当前状态是SHUTDOWN 以上 并且没有任务进来，并且队列非空，返回false
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
            	// 1.如果当前运行线程大于最大可容运行线程数
            	// 2.增加核心线程时，已经超过最大核心线程数 或 增加临时线程时，大于最大线程数。
            	// 直接返回false
                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.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());
					// 检查当前是RUNNING状态，或者是SHUTDOWN 但是此时无任务进来，
					//如果此时的thread还是运行状态，则抛异常。
					// 注意：此时的线程是刚刚创建的，并没有调用run，他此时运行状态说明有问题。
                    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 
                            largestPoolSize = s;
                         // 入池成功
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                	// 启动线程，注意: 这里启动的是池中的工作线程，不是提交进来的线程。
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
            	// 工作线程启动失败，
            	//1.从池中移除该线程
            	//2.运行线程数量减一
            	//3.检查线程中是否已经终止，这里会调用terminated方法
                addWorkerFailed(w);
        }
        return workerStarted;
    }

在这里和大家讲下自己看这段代码的经历，第一个让我有疑惑的，就是retry这个标记，其实后面看明白了其实就是一个跳出循环的标记。

我们看这个方法逻辑，其实他就是新建了一个工作线程，并且启动了工作线程。

我们在这里注意下：
这个方法会在三种情况下返回false：

如果当前状态是SHUTDOWN 以上并且没有任务进来，并且队列非空，返回false
1.如果当前运行线程大于最大可容运行线程数2.增加核心线程时，已经超过最大核心线程数或增加临时线程时，大于最大线程数。直接返回false
工作线程启动失败。

在这里新建线程的流程可以看的很明白，但是启动线程呢？
好的，我们继续往下。

runWorker

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
                // 1.当前线程池为STOP状态，且工作线程未被中断，中断当前工作线程。
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                	//扩展接口，处理执行任务前逻辑
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                    	// 执行任务： 注意：这样调用的run，非start
                        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;
                    // 当前工作线程处理任务量加1
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

相信看到这里，大部分同学都已经了解了这个启动线程流程了，首先工作线程会去处理自带的任务，如果没有自带任务就执行队列中的任务。
所以我们整理下execute方法整体流程：
1.线程进来首先判断当前核心线程是否已经全部创建成功，全部创建成功则创建临时线程，没全部创建则优先新建核心线程，临时线程创建+核心线程已经等于最大线程数则放入队列，如果队列也满了，就执行拒绝策略。
2.执行任务优先执行线程自带任务，无自带任务则执行队列中的任务。

submit

其实搞懂了execute方法原理后，搞懂submit方法就简单了。

	public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        // 对提交的任务进行包装
        RunnableFuture<T> ftask = newTaskFor(task);
        // 执行任务
        execute(ftask);
        return ftask;
    }

可以看submit方法的源码，他就是对提交的任务进行了包装，然后再调用execute方法，我们去看下他是如何包装的，然后run方法的实现。

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }

public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

可以看到包装的时候给内部变量赋值了两个参数：
我们看下他的run方法，（这个run方法是给execute内部的任务，不理解的可以回顾下execute源码逻辑）

public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
        	// 这个callable就是我们提交给submit的任务了
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

这里给大家把ThreadPoolExecutor的底层主要核心逻辑讲解了，我这里只是根据我自身的理解讲的，大家有什么想法可以评论沟通下，我会随时回复的，接下来给大家讲下ThreadPoolExecutor的子类，ScheduledThreadPoolExecutor

爱蛋蛋真是太好了

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
从0了解线程池，教你讲哭面试官。

从0了解线程池，教你讲哭面试官。线程池作用线程池结构线程池核心参数核心方法一、executeworkerCountOfaddWorkerrunWorker线程池作用很多同学在工作中使用线程池的场景并不多，所以对线程池的了解也不多。但在面试中，线程池的面试比重还是挺大的。在这里我给大家讲下我对线程池的理解。1.线程池可以复用线程，减少重复创建线程的消耗。大家应该知道线程的创建和销毁，在任务耗时不大的时候，会大量占用CPU和消耗性能。如果这时候使用线程池的话，能有效的复用线程，减少不必要的损耗。
复制链接

扫一扫

专栏目录