ThreadPoolExecutor线程池源码分析

系列文章目录

第一章ThreadPoolExecutor源码分析前期基础知识

第二章ThreadPoolExecutor线程池源码分析

---

---

前言

相信大家在看了第一章的ThreadPoolExecutor源码分析前期基础知识的作作为基础储备的前提下，再阅读第二文章的ThreadPoolExecutor基于线程源码分析一定会轻松很多。本篇文章主要会对线程池进行源码分析

---

一、任务添加

1、入口方法

// excute()添加任务的入口
 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();
            //如果线程池状态不是RUNNING 则移除任务
            if (! isRunning(recheck) && remove(command))
                reject(command);
            //工作线程数是0的时候新增一个非核心线程处理任务
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //如果队列添加失败
        else if (!addWorker(command, false))
            reject(command);
    }

2、任务添加

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        //两个循环的目的是为了判断线程池状态以及是否可以新增任务
        for (;;) {
            int c = ctl.get();
            //线程池状态
            int rs = runStateOf(c);
            //请看下文详细说明1
            //线程池的状态 
            //rs == SHUTDOWN STOP TIDYING TERMINATED
            //rs!= SHUTDOWN ||firstTask !=null|| workQueue.isEmpty()
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                //判断是否大于设置的容量
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                 //线程数+1  
                if (compareAndIncrementWorkerCount(c))
                    //跳出外层循环
                    break retry;
                c = ctl.get(); 
                //如果添加失败 如果线程池的状态发生变化 继续新增
                if (runStateOf(c) != rs)
                    //跳出内层循环
                    continue retry;
            }
        }
=====================================添加任务========================================
        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 {
                    int rs = runStateOf(ctl.get());
                    //线程池状态是RUNNING或者 SHUTDOWN && firstTask == null
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) 
                            throw new IllegalThreadStateException();
                         //work添加到集合中   
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        //添加成功标识    
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    //启动线程 最终执行worker的run方法
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
             //如果没有启动 失败处理  该方法请看详细说明2
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

2.1、详细说明1

 SHUTDOWN STOP TIDYING TERMINATED
SHUTDOWN ||firstTask!=null ||workQueue为空
1、rs=SHUTDOWN && （firstTask!=null|workQueue为空）因为SHUTDOWN状态不接受新任务、需要处理线程池里任务
2、STOP TIDYING TERMINATED 不接受任务、不处理任务

2.2、详细说明2

     private void addWorkerFailed(Worker w) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (w != null)
                //移除Worker
                workers.remove(w);
             //线程数-1   
            decrementWorkerCount();
            //尝试中断 请看详细说明3
            tryTerminate();
        } finally {
            mainLock.unlock();
        }
    }

2.3、详细说明3

 final void tryTerminate() {
        for (;;) {
            int c = ctl.get();
			//1、RUNNING  
			//2、TIDYING、TERMINATED  说明已经状态已经中断成功 无需再次中断
			//3、SHTUDOWN且队列不为空   还存在未处理的任务 不能中断
            if (isRunning(c) 
                runStateAtLeast(c, TIDYING) ||
                (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
		        //没有资格中断任务
                return;
			
            if (workerCountOf(c) != 0) {
			    //中断一个空闲线程（w.tryLock()获得锁成功）
                interruptIdleWorkers(ONLY_ONE);
                return;
            }

            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
			     //设置状态  TIDYING
                if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                    try {
					    //空方法
                        terminated();
                    } finally {
					    //设置状态  TERMINATED
                        ctl.set(ctlOf(TERMINATED, 0));
                        termination.signalAll();
                    }
                    return;
                }
            } finally {
                mainLock.unlock();
            }
        }
    }

二、Worker处理任务

2.1、runWorker

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); 
        boolean completedAbruptly = true;
        try {
            //循环处理任务 核心和非核心线程处理
            while (task != null || (task = getTask()) != null) {
                w.lock();
               //1、如果是STOP以上的状态
               //2、当前线程设置过中断标识、并且是STOP以上的状态、并且当前线程没有设置中断标识
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    //设置中断标识
                    wt.interrupt();
                try {
                    //前置方法
                    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 {
            //处理非worker的退出 （RUNING状态只会处理非核心线程）
            processWorkerExit(w, completedAbruptly);
        }
    }

2.2、getTask

  private Runnable getTask() {
       //前一次
       获取任务是否超时
        boolean timedOut = false; 
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            //1、SHUTDOWN && workQueue.isEmpty() 
            //2、STOP以上  不处理任务 直接返回
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                //工作线程数-1
                decrementWorkerCount();
                return null;
            }
            int wc = workerCountOf(c);
            //allowCoreThreadTimeOut  默认False ||是否大于核心线程
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            //wc > maximumPoolSize 我猜是被其他线程修改最大线程 越过了addWorker的校验
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                //工作线程数-1 超时的线程会在这里被移除
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }
            try {
               //poll() 超过等待时间返回null 
               //take() 如果队列为空 则阻塞
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                //poll超时     
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

2.3、processWorkerExit

 private void processWorkerExit(Worker w, boolean completedAbruptly) {
        if (completedAbruptly) 
            //工作线程数-1
            decrementWorkerCount();

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            completedTaskCount += w.completedTasks;
            //移除worker
            workers.remove(w);
        } finally {
            mainLock.unlock();
        }
        //尝试中断线程
        tryTerminate();
        int c = ctl.get();
        //小于stop
        if (runStateLessThan(c, STOP)) {
            //正常逻辑走完流程
            if (!completedAbruptly) {
                int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
                if (min == 0 && ! workQueue.isEmpty())
                    min = 1;
                //工作线程是否大于核心线程    
                if (workerCountOf(c) >= min)
                    return; 
            }
            //添加非核心线程
            addWorker(null, false);
        }
    }

三、线程池的状态转换

3.1、RUNNING>SHUTDOWN

 调用线程池的shutdown()方法时，线程池由RUNNING -> SHUTDOWN

   public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            //设置状态 
            advanceRunState(SHUTDOWN);
            //设置中断标识
            interruptIdleWorkers();
            onShutdown(); 
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
    }
    private void advanceRunState(int targetState) {
        for (;;) {
            int c = ctl.get();
            //当前线程池状态》=SHUTDOWN
            if (runStateAtLeast(c, targetState) ||
                //设置状态 
                ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
                break;
        }
    }  

   private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers) {
                Thread t = w.thread;
                //对空闲的核心线程进行中断标识
                 //如果尝试获取锁成功 说明核心线程池空闲
                if (!t.isInterrupted() && w.tryLock()) {
                    try {
                        t.interrupt();
                    } catch (SecurityException ignore) {
                    } finally {
                        w.unlock();
                    }
                }
                //传值false
                if (onlyOne)
                    break;
            }
        } finally {
            mainLock.unlock();
        }
    }    

3.2、(RUNNING or SHUTDOWN ) > STOP

 调用线程池的shutdownNow()方法时，线程池由RUNNING、SHUTDOWN>STOP
 public List<Runnable> shutdownNow() {
        List<Runnable> tasks;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            //设置状态
            advanceRunState(STOP);
            //设置中断标识
            interruptWorkers();
            //返回没有处理的任务
            tasks = drainQueue();
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
        return tasks;
    }
   private void interruptWorkers() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers)
                w.interruptIfStarted();
        } finally {
            mainLock.unlock();
        }
    }
     void interruptIfStarted() {
            Thread t;
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                    //设置中断标识  很多博客说stop会中断正在执行的线程 其实是不对的
                    //第一章有详细说明如何中断线程
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }