线程池底层原理及源码解析（最详细的解析）

最新推荐文章于 2023-12-22 02:21:31 发布

混蛋阿飞

最新推荐文章于 2023-12-22 02:21:31 发布

阅读量916

点赞数 10

文章标签：多线程并发编程队列 java

本文链接：https://blog.csdn.net/m0_46455412/article/details/109114144

版权

Executor框架集

Executor框架集对线程的调度进行了封装，把任务的提交和执行进行了解耦，我们不需要任务如何被执行的，只需要把需要执行的任务丢进线程池，同时还提供了大量的方法进行线程的调度。
1.Executor（接口）
线程池的最顶层接口，这个接口只定义了一个方法就是execute（）用于执行已经提交的Runnable任务；

public interface Executor {
    void execute(Runnable command);
}

2.ExecutorService（接口）
java.util.concurrent.ExecutorService接口继承自最顶层接口Executor，提供了一系列方法对Executor的生命周期进行管理。

public interface ExecutorService extends Executor {

   /*
   有序完成所有提交的任务，不再接受新任务。如果线程池已经关闭，那么调用此方法不会起任何效果（本质是把线程池设置为shutdown状态，同时尝试执行完成等待队列里的任务）
   */
    void shutdown();
	/*
	将线程池设置为stop状态，正在执行的任务则被停止，没被执行的任务则返回（等待队列里的任务）
	*/
    List<Runnable> shutdownNow();
  /*
  返回true说明已经关闭
  */
    boolean isShutdown();
	/*
	返回true说明执行关闭后，所有任务都已完成
	*/
    boolean isTerminated();
    /*
    阻塞指定的时长，在调用shutdown之后，等待所有任务的完成
    */
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
	/*
	提交一个带返回值的(Calllable)任务用于执行，返回一个Future对象来代表该任务未来的结果，注意是未来的结果（因为这个过程异步）
	Future的get方法会在任务成功完成后返回结果，get操作会阻塞线程
	*/
    <T> Future<T> submit(Callable<T> task);
   /*
   提交一个不需要返回值的任务（Runnable）并且返回Future；如果执行成功，那么Future的get会返回参数T
   */
    <T> Future<T> submit(Runnable task, T result);
   /*
   提交一个不需要返回值的任务（Runnable）并且返回Future；如果执行成功，那么Future的get会返回null
   */
    Future<?> submit(Runnable task);
    /*
    执行提供的任务集合，全部任务完成后返回Future列表；
    此列表会和任务集合存在顺序对应关系，Future的isDone为true时，表示对应任务完成
    */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;
    /*
    执行提供的任务集合，全部任务完成后或超时后返回Future列表，那些超时后的任务会被取消；
    此列表会和任务集合存在顺序对应关系，Future的isDone为true时，表示对应任务完成
    */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;
     /*
       执行给定的任务集合，返回第一个未抛出异常且正常返回的结果，然后立刻终止所有线程；注意：该集合不建议修改，否则返回结果会是null
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;
     /*
      执行给定的任务集合，返回在指定时间内的正常返回的结果，如果超时未完成则抛出超时异常。；注意：该集合不建议修改，否则返回结果会是null
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

3.AbstractExecutorService（抽象类）
AbstractExecutorService（抽象类）实现了ExecutorService接口，基本实现了ExecutorService中声明的所有方法；这里不再详细介绍该抽象类。

4.ThreadPoolExecutor
ThreadPoolExecutor是ExecutorService最常见的实现类，也就是常说的线程池。ThreadPoolExecutor继承了类AbstractExecutorService。
下面重点介绍内部实现：

public class ThreadPoolExecutor extends AbstractExecutorService {
  //初始化线程池状态为RUNNING，线程池数量为0. 也就是我们new完线程池的时候，池子里的线程数量为0.状态就是running状态了
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    // Integer.SIZE为32，所以COUNT_BITS =29.
    private static final int COUNT_BITS = Integer.SIZE - 3;
    //CAPACITY 表示线程池允许的最大线程数2的29次方-1
    private static final int CAPACITY   = (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
    //通过ctl获取线程池的运行状态
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    //通过ctl获取Worker计数，也就是工作线程数
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    //通过workerCount和运行状态获取ctl新值
    private static int ctlOf(int rs, int wc) { return rs | wc; }

Ctl用来表示线程池的状态和线程数，在ThreadPoolExecutor中使用32位二进制数来表示线程池的状态和线程池中线程数量，其中前3位表示线程池状态，后29位表示线程池中的线程数。

接下来我们看线程池的状态一共有5种：
RUNNING：运行中，可以接受新任务，并且处理排队任务。
SHUTDOWN：关闭，不再接受新任务，不过仍然会处理排队任务。
STOP：停止，不再接受新任务，也不处理排队任务，同时中断处理中的任务。
TIDYING：整理，当所有任务终止，workerCount计数为0，线程会转换到TIDYING状态，并且执行terminal()的钩子方法（terminal会在TIDYING状态后自动调用）。
TERMINATED：终止，说明terminal()方法执行完成。
在这里插入图片描述
然后我们看runStateof、workerCount0f和ctlOf三个静态方法：
RunStateOf获取ctl高三位，也就是线程池的状态。WorkerCountOf获取ctl低29位，也就是线程池中的线程数。ctlOf计算ctl新值，也就是线程池状态和线程池中线程数量。

我们初始化一个线程池时，可以配置的成员变量：

   /**
    线程池的基本大小，就算没有任务执行，线程池至少也要保持这个size，不过如果allowCoreThreadTimeOut设置为true，那么corePoolSize可能会为0.  
     */
    private volatile int corePoolSize;

    /**
    线程池最大容量，线程数不能超过这个数量
     */
    private volatile int maximumPoolSize;
     /**
    决定线程多长时间没有接到任务后可以结束，线程空闲时间
     */
    private volatile long keepAliveTime;

	 /**
	等待队列
     */
	private final BlockingQueue<Runnable> workQueue;
	 /**
    线程工厂，用于生成线程池中的工作线程
     */
    private volatile ThreadFactory threadFactory;

    /**
    工作线程超过最大线程数时，被拒绝拒绝的任务的处理策略
     */
    private volatile RejectedExecutionHandler handler;

其他重要的成员变量

      /**
    是否运行核心线程空闲超时后被回收（默认是false，也就是核心线程即使空闲很久了，也不会被回收，照样在线程池中运行）
     */
    private volatile boolean allowCoreThreadTimeOut;
	/**
    所有的工作线程，只有持有lock锁的时候才会处理
     */
    private final HashSet<Worker> workers = new HashSet<Worker>();
     /**
    线程池中曾经出现过的最大线程数量
     */
    private int largestPoolSize;

    /**
    线程池已完成的任务数量
     */
    private long completedTaskCount;

ThreadPoolExecutor提供了四个构造方法。

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }

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

 
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }
    
    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;
    }

前三个方法都是调用最后一个方法去实例化线程池的，通过给这个七大属性赋值，完成线程池对象的创建。
这里额外介绍另外一个实例化线程池的类Executors。他也提供了线程池的创建，里面提供了大量静态方法去构造我们想要的线程池。但是，不建议使用Executors类默认提供的静态方法，因为可能造成oom。
他们为什么会造成oom？
FixedThreadPool和SingleThreadPool：允许的请求队列长度为Integer.MAX_VALUE,可能会堆积大量的请求，造成oom。
CachedThreadPool：允许创建的最大线程数量为Integer.MAX_VALUE，也会造成oom
为了让下面的源码看起来更轻松，我先介绍一下线程池的运行原理：
1.通过execute方法提交任务时，当线程池中的线程数小于corePoolSize时，新提交的任务将通过创建一个新线程来执行，即使此时线程池中存在空闲线程。
2.通过execute方法提交任务时，当线程池中的线程数量达到corePoolSize时，新提交的任务将被放入workQueue中，等待线程池中的线程调度执行。
3.通过execute方法提交任务时，当workQueue已存满，且maximumPoolSize大于corePoolSize时，新提交的任务将通过创建新线程执行。
4.当线程池中的线程执行完任务空闲时，会尝试从workQueue中取头结点任务执行。
5.通过execute方法提交任务时，当线程池中线程数达到maximunPoolSize，并且workQueue也存满时，新提交的任务由RejectedExecutionHandler执行拒绝操作。
6.当线程池中线程数超过corePoolSize，并且未配置allowCoreThreadTimeOut=true，空闲时间超过keepAliveTime的线程会被销毁，保持线程池中线程数为corePoolSize。
7.当设置了allowCoreThreadTimeOut=true时，任何空闲时间超过keepAliveTime的线程都会被销毁。

下面介绍真正执行任务的方法：
execute()方法
submit的底层也是通过execute实现的，所以这里只介绍execute。
execute()的实现主要有3个步骤：
1.如果当前执行的线程数小于核心线程（corePoolSize），那么会尝试新增一个线程并启动它来执行任务（也就是源码中的addWorker方法），如果新增成功，那么直接返回。
2.如果添加工作线程失败，那么会尝试把任务放入到队列。
3.如果任务不能加入队列，那么可能是线程池已经关闭了或队列满了，此时拒绝任务。
其实现源码如下：

public void execute(Runnable command) {
		//必须要有一个可执行的任务
        if (command == null)
            throw new NullPointerException();
        //上面介绍过了ctl了,获取线程池的状态和工作线程数
        int c = ctl.get();
        //如果工作线程数小于核心线程数，那么去新增核心线程
        //注意这里的addworker后面的参数true，这个true标记着是要去新增核心线程
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
             //添加核心线程失败，有多种可能，更新一下线程池的状态（这里去思考下添加核心线程失败的原因，需要去看addworker里面到底做了什么，所以我在后面会详细介绍）
            c = ctl.get();
        }
        //到这一步说明了什么？核心线程数目已经满了，不能再创建核心线程了（此时有人就会说，下面添加失败了不也到这一步了吗，别急，你暂时先认为到这一步是核心线程满了，不能再创建核心线程，该入队了）
        //如果线程池还在运行状态，且核心线程满了，开始入队
        if (isRunning(c) && workQueue.offer(command)) {
        //入队成功
            int recheck = ctl.get();
            //再次检查线程池，如果线程池不是运行状态且可以移除任务了，我们就会抛出拒绝策略
            if (! isRunning(recheck) && remove(command))
                reject(command);
                //当线程池在运行状态可能会进入这个else if
                //当线程不在运行状态但不能移除任务了也可能进入这个else if
            else if (workerCountOf(recheck) == 0)
            //我们先考虑第一种情况，就是线程池运行状态，但工作线程数为0了，那么我们addworker一下
            //第二种情况，线程不在运行了但该任务却入队了也没有移除成功，而且工作线程数为0了，所以我们addwoker一下创建非核心线程去处理队列里的任务
                addWorker(null, false);
            //注意这里的addworker后面的参数是null和false，false代表创建的非核心线程，null这个参数传入的时候就代表的是 我们创建的非核心线程是去处理队列里的任务
            //（下面我们重点介绍addWorker方法以及为什么传入null的时候是去处理队列任务）
        }
        //进入该分支说明：线程池非运行状态或运行状态但不能入队了（队列满了），这时候去创建非核心线程
        else if (!addWorker(command, false))
        //如果创建非核心线程失败了，执行拒绝策略（为什么会创建非核心失败啊，达到最大线程数了！）
            reject(command);
    }

下面介绍addWorker()方法，因为上面抛出了好多问题还未解决。
1.addWorker()传入false的时候为什么创建非核心线程，传入true创建核心线程？
2.addWorker()传入null的时候，为什么是去执行队列的任务？
在分析addWorker()方法之前呢，我们还需要再思考一个问题，就是else if (workerCountOf(recheck) == 0){addWorker(null, false);}这一句代码，什么时候会出现线程池中的线程数为0啊？还记得前面我介绍的线程池的几大核心参数，corePoolSize不就标记着线程池就算没任务执行了也要保持这个数量吗！所以出现线程池中的线程数为0，只有在配置了corePoolSize为0的情况下才会出现，如果你配置了corePoolSize非0，那么线程池中的线程数目是不会出现为0的情况。（这里说的是allowCoreThreadTimeOut为false的情况，如果为true的话，就会出现线程数为0的情况）
总结一句话：配置了允许超时回收核心线程为true，那么就会出现线程数为0，如果没有配置为true，但corePoolSize为0，也会出现这种情况。
好了，回到正题，分析addWorker源码：

 private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();  
            int rs = runStateOf(c); //获取线程池的运行状态，之前介绍过了，高三位代表运行状态，不再赘述

            // 过滤操作：过滤这种情况下不再新增线程去处理任务
            //如果rs是运行状态，那么会直接到下面进行新增线程，不会进入该分支，rs>=shutdown代表非running状态
            //如果线程池是非运行状态且不是（线程池是关闭状态，firstTask为null，workQueue非空）的情况，我们不去新增线程（return false）
            //这句话的意思是如果线程池不在运行了，如果正好是关闭状态且firstTask为null（什么时候为null啊 就是我刚才说的工作线程为0的时候）且等待队列不为空，那么我们就可以去创建新线程去处理队列里的任务
            //shutdown的状态，工作线程数又为0，队列又不为空，这时候会去创建非核心线程去处理队列里的任务
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
            //获取工作线程数
                int wc = workerCountOf(c);
                //再次确认能否创建对应的线程
                //如果工作线程数目大于最大容量了 return false 或工作线程数目超过了对应的线程数目，return false
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                    //到这里说明，线程池允许创建对应的线程了且没有超过对应的数量
                    //线程数目加1（这里是cas操作，自己可以去研究）
                if (compareAndIncrementWorkerCount(c))
                	//跳出外层循环（下面我会解释一下这个用法）
                    break retry;
                    //如果cas操作失败，线程数目没有+1
                    //再次获取线程的状态
                c = ctl.get();  // Re-read ctl
                //判断线程的状态和之前（刚进入循环的状态）状态进行比较
                //如果不同，说明线程池状态发生了变化，重新跳到retry的标记处进入外层循环
               //如果相同，说明线程池状态没有变化，继续进行内层循环
                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 {
        //创建一个worker线程
            w = new Worker(firstTask);
            //这里需要介绍下Worker的内部实现，下面我会介绍
            //记住这里的w.thread取出来的就是worker这个对象本身
            final Thread t = w.thread;
            //判断worker线程非空之后上一把重入锁
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {           
                    // 获取线程池运行状态
                    int rs = runStateOf(ctl.get());
					//如果线程池是运行状态或firstTask为null（工作线程数为0的时候才会为null）
					//也就是线程是运行状态或shutDown状态但线程池中没有工作线程了，才去把worker线程加入到workers中（hashset）
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {				//判断worker线程是否还存活，预检查一下
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                            //检查通过后，添加到workers中
                        workers.add(w);
                        int s = workers.size();
                        //更新下线程池中曾出现过最大的线程数
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;//添加工作线程成功
                    }
                } finally {
                    mainLock.unlock();//释放锁
                }
                //如果添加成功了，就启动该线程
                if (workerAdded) {
                    t.start();//这里的t.start在后面我会介绍
                    workerStarted = true;//标记工作线程启动了
                }
            }
        } finally {
        //如果工作线程没有启动，就将worker线程从线程池移除，并将线程数减1
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

总结一下addWorker做了一些什么事情：
1.通过判断线程池的状态、线程池中的工作线程数目是否为0、队列是否为空来确定是否创建线程
2.再次判断你创建的是核心还是非核心，以及有没有超出你之前设置参数的值
3.以上都通过了，cas一下，线程数+1,跳出循环了，进入到下面的代码，去加入到wokers以及t.start操作了
4.将新增worker线程加入到workers中，然后启用线程。
大概这个流程吧，但是我们还未解决上面的几个问题！
第一个问题是，execute()方法中的第二步骤，为什么说到了第二步的时候，会说这样一句话：（此时有人就会说，下面添加失败了不也到这一步了吗，别急，你暂时先认为到这一步是核心线程满了，不能再创建核心线程，该入队了）
为什么会这样说呢，这是因为addWorker增加线程的时候是做的盲循环，也就是会一直尝试去线程数+1,直到天荒地老啊,一直到核心线程数满了就会return false了，所以到第二步的时候就默认认为核心线程数满了，尝试入队！
第二个问题是addWorker传入null的时候为什么是处理队列任务？
这里需要介绍Worker的实现了，他是AQS的一个子类，又实现了Runnable接口。
addWorker中的代码：

 w = new Worker(firstTask);
 final Thread t = w.thread;
 ...
 t.start();

我们再来看Worker的内部实现：

 Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);//这里this就是worker本身
        }

因为实现了Runnable接口，所以t.start()也会进入到自己重写的run方法来执行具体的业务逻辑。
下面我们看重写的run()方法：

 public void run() {
 //该方法是ThreadPoolExecutor提供
            runWorker(this);
        }

这是啥？run方法里面又调用了runWorker()，那么我们再来看runWorker里面具体做了哪些操作

 final void runWorker(Worker w) {
 		//获取当前线程
        Thread wt = Thread.currentThread();
        //取出firstTask，w是worker本身
        Runnable task = w.firstTask;
        //将worker的firstTask设置为空
        w.firstTask = null;
        //释放锁，（设置state为0，允许中断）
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
        //如果task不为null，则直接进入循环执行task
        //如果task为null，那么会调用getTask()
        //getTask是一个无线循环，他会从阻塞队列中不断取出任务来执行，当阻塞队列中所有任务都被取完之后，循环结束
            while (task != null || (task = getTask()) != null) {			//上一把锁，记住worker自己是个AQS，保证同一个worker不会同时执行下面代码
                w.lock();
                // 当线程池是处于stop或tidying，terminal状态时，设置当前线程处于中断状态
                //否则当前线程就处于Running或shutdown状态，确保当前线程不处于中断状态
                // 重新检查当前线程池的状态是否大于等于stop状态
                // shutdownNow race while clearing interrupt
                if ((runStateAtLeast(ctl.get(), STOP) ||  //线程池的状态至少应该高于stop
                     (Thread.interrupted() && //线程被中断
                      runStateAtLeast(ctl.get(), STOP))) &&   //再次检查，线程池状态至少应该高于STOP
                    !wt.isInterrupted())  //wt线程（当前线程)没有被中断
                    wt.interrupt(); //中断当前线程
                try {
                //执行task之前调用钩子方法
                    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;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
        //执行完成后，从workers中移除worker
            processWorkerExit(w, completedAbruptly);
        }
    }

好了，现在就可以解释为什么addWorker中传入null会处理队列任务了。
addWorker中传入null和false，null赋值给了firstTask，在runWorker方法中，取出了Worker的firstTask赋值给task，然后将firstTask置为空，然后进入while循环,task此时为空，所以会调用getTask去处理队列任务！
下面不再介绍getTask方法，有兴趣的可以继续往下看源码。
到这里，基本把线程池的底层逻辑讲清楚啦！

混蛋阿飞

关注

10
点赞
踩
11

收藏

觉得还不错? 一键收藏
2
评论
线程池底层原理及源码解析（最详细的解析）

标题Executor框架集Executor框架集对线程的调度进行了封装，把任务的提交和执行进行了解耦，我们不需要任务如何被执行的，只需要把需要执行的任务丢进线程池，同时还提供了大量的方法进行线程的调度。1.Executor（接口）线程池的最顶层接口，这个接口只定义了一个方法就是execute（）用于执行已经提交的Runnable任务；public interface Executor { void execute(Runnable command);}2.ExecutorService
复制链接

扫一扫