线程池源码解析4.runWorker()

worker总流程图

1.runWorker()

大体流程：

先会执行当前的worker内部的任务，执行任务时需要加锁 (worker内部的锁)，如果执行内部任务成功时会尝试去队列中拿任务继续执行(可能会被阻塞)。当执行任务失败时会将当前的worker从workers集合中删除。

	
	// worker 就是创建的worker(Runnable)
	final void runWorker(Worker w) {
        //就是worker内部的Thread属性
        Thread wt = Thread.currentThread();
        //将任务赋值给task
        Runnable task = w.firstTask;
        w.firstTask = null;
        
        /*
         *   这里不是解锁操作，这里是为了设置state = 0 以及 ExclusiveOwnerThread = null.因为起始状态state = -1, 
         *   不允许任何线程抢占锁，这里就是初始化操作。
         */   
        w.unlock(); 
        
        /*
         * 表示是否突然退出标志位，
         * true->  发生异常了，当前线程突然退出，后面会做处理
         * false-> 正常退出  
         */
        boolean completedAbruptly = true;
        try {
            
            /*
             *  条件一：
             *  task != null 值得就是firstTask是不是NULL，不是NULL执行循环体
             *   
             *  条件二：
             *  getTask()方法就是当前线程从BlockingQueue中获取任务，此方法会阻塞。
             *  getTask() == null 当前线程需要执行结束逻辑
             */ 
            while (task != null || (task = getTask()) != null) {
                /*
                 * 加锁 设置独占锁为当前线程 防止其他线程将当前线程中断。
                 * 为什么要设置独占锁，shutdown时会判断当前worker状态，根据独占锁是否空闲来判断当前worker是否正在工作。
                 */
                w.lock();
                
   /*
    *  这里有两个作用：
    *  1、线程池处于STOP/TIDYING/TERMINATION状态时需要设置线程的中断标志位
    *  2、强制刷新标志位，通过Thread.interrupted()方法，因为有可能上一次执行task时，当先线程的中断标志位被设置为了true，
    *  且没有处理，这里就需要处理一下。
    */
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    //设置中断标志位为true。
                    wt.interrupt();
                
                try {
                    //钩子方法，留给子类实现
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        /*
                         * task可能是FutureTask(通过线程池的submit()提交的方法)，
                         * 调用run方法执行业务逻辑。
                         */
                        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
                    task = null;
                    //更新worker完成任务的数量
                    w.completedTasks++;                    
                    /*
                     * worker处理完一个任务后，会释放掉独占锁
                     * 1.正常情况下，会再次回到getTask()获取任务(外面是一个while循环) 
                     * 2.任务执行出异常，
                     */
                    w.unlock();
                }
            }
            
            /*
             * 什么情况下，回来到这里？
             * 1.当getTask()返回NULL时，说明当前线程应该执行退出逻辑了。。
             */
            completedAbruptly = false;
        } finally {
            
            /*  
             *  task.run()内部抛出异常，直接从w.unlock那里跳到这一行。
             *  正常退出：completedAbruptly = false
             *  异常退出：completedAbruptly = true。
             */
            processWorkerExit(w, completedAbruptly);
        }
    }

2.getTask()

	/*
	 *  什么情况下会返回NULL?
 	 *  1.当前线程状态 >= STOP，成立说明当前的状态最低也是STOP，一定要返回NULL。
	 *  2.线程池状态是SHUTDOWN，并且队列中没有元素
	 *  3.线程池中的线程数量超过最大限制时，会有一部分线程返回NULL。
	 *  4.线程池中的线程数超过了corePoolSize时，会有一部分线程 获取任务超时后 返回NULL。
	 */

	private Runnable getTask() {
     
     	//表示当前线程获取任务是否超时，默认是false，true表示已超时。
        boolean timedOut = false; 
		
     	//自旋
        for (;;) {
            //获取最新的ctl的值
            int c = ctl.get();
            
            //获取线程池当前运行状态
            int rs = runStateOf(c);

            /*
             * 这里判断如果说线程池状态是非Running状态 && (队列中没有任务了 || 线程池当前最低状态也是STOP)
             * 就会使用CAS的方式将ctl值-1，即减少一个工作线程数。最后直接返回NULL。
             */ 
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            /*
             * 执行到这里，有几种情况？
             * 1.线程池是Running状态，
             * 2.线程池是SHUTDOWN状态，但是队列中还有任务。(此时可以创建线程)
             */
            
            //获取线程池中的线程数量
            int wc = workerCountOf(c);

            /*
             * timed表示当前线程在从队列中获取任务的时候是否有超时时间。
             * poll(xx, xx)获取时可以设置超时时间，take()没有超时时间。
             * 
             *  设置此参数的主要依据就是，判断allowCoreThreadTimeOut是否允许核心线程超时被回收(注意：核心线程与非核心线程没有任何区别，
             * 	 只是通过设置的核心线程数量最后保留指定的线程)，如果此参数为true，表示核心线程允许被回收，以及当前线
             *   程数的数量已经大于了核心线程数，说明当前线程当获取任务超时时一定可以被回收。 
             */           
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
			
            
            /*
             * 判断当前线程是否达到了回收的标准，
             * 当获取任务超时并且核心线程可以被回收并且 当前线程池线程数量大于1并且队列中没有任务了，当前线程就达到回收标准了，
             * 当确实需要回收时才会被回收。
             */
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                
                /*
                 * CAS方式减去一个线程数，成功后返回NULL.
                 * CAS有可能会失败，为什么会失败？
                 *  1.其他线程先你一步退出
                 *  2.线程池状态发生了变化。
                 */
                if (compareAndDecrementWorkerCount(c))
                    //直接返回 null。
                    return null;
                
                /*
                 * 如果CAS失败，再次自旋，timed就有可能是false了，因为当前线程CAS失败，
                 * 很有可能是因为其他线程成功退出导致的，再次自旋时检查发现，当前线程就可能不属于回收范围了。
                 */
                continue;
            }
            try {
                /*  获取任务的逻辑
                 *  根据timed的值，判断去队列中获取任务是使用带超时时间的还是不带超时时间的。 (注意：如果获取不到任务都会阻塞)
                 */
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                
                //获取到了任务
                if (r != null)
                    return r;
                //说明当前线程超时了。继续进行自旋。
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

3.processWorkerExit()

	/*
	 * @param w : 表示当前worker
	 * @param completedAbruptly：为true，表示当前worker是因为任务出异常退出的，
	 * false表示当前worker是因为没有获取到任务。
	 */
	private void processWorkerExit(Worker w, boolean completedAbruptly) {
        /*
         * 条件成立：代表当前worker是发生异常退出的，即在执行任务期间向上抛出异常了。
         * 异常退出时，ctl计数并没有-1，
         */
        if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
            //CAS将ctl - 1；
            decrementWorkerCount();
		
        final ReentrantLock mainLock = this.mainLock;
        //加锁(全局锁)
        mainLock.lock();
        
        try {
            //将当前worker完成的任务总数累加到全局总数上
            completedTaskCount += w.completedTasks;
            //将当前worker从线程池(workers就是一个HashSet)移除
            workers.remove(w);
        } finally {
            //解锁
            mainLock.unlock();
        }
		
        //后面详细讲
        tryTerminate();
		
        //获取ctl的值
        int c = ctl.get();
        
        //条件成立：当前线程池状态为running 或者 shutdown状态。
        if (runStateLessThan(c, STOP)) {
            
            //这里成立说明当前线程是正常退出。
            if (!completedAbruptly) {
                
                //min表示线程池最低可以持有的线程数量
                int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
                
                /*
                 * 线程池状态：RUNNING SHUTDOWN
                 * 条件一：mid == 0成立
                 * 条件二：队列不空
                 * 说明队列中还有任务，起码得留一个线程。
                 */
                if (min == 0 && ! workQueue.isEmpty())
                    min = 1; //赋值为1
                
                /*
                 * 条件成立： 线程池中还拥有足够的线程时，后续就不需要调用addWorker()了
                 * 考虑一个问题： workerCountOf(c) >= min  -> (0 >= 0)?
                 *  当线程池中的核心线程数是可以被回收的情况下，会出现这种情况，这种情况下，
                 *  当前线程池中的线程数会变为0，下次在提交任务时，会再创建线程。 
                 */
                if (workerCountOf(c) >= min)
                    return; 
            }
            
            /*
             * 来到这里的情况
             * 1.completedAbruptly为true，表示执行任务时异常退出了。
             * 2.当队列中还有任务时，起码留一个线程，这里就会创建一个线程(worker)。
             * 3.当前线程数 < corePoolSize，此时会创建线程，维护corePoolSize。
             */
            addWorker(null, false);
        }
    }