Executor线程池原理与源码解读

线程

线程是调度CPU资源的最小单位，线程模型分为KLT模型与ULT模型，JVM使用的KLT模型，Java线程与OS线程保持1:1的映射关系，也就是说有一个java线程也会在操作系统里有一个对应的线程。Java线程有多种生命状态
NEW,新建
RUNNABLE,运行
BLOCKED,阻塞
WAITING,等待
TIMED_WAITING,超时等待
TERMINATED，终结
线程状态切换图

线程池
在web开发中，服务器需要接受并处理请求，所以会为一个请求来分配一个线程来进行处理。如果每次请求都新创建一个线程的话实现起来非常简便，但是存在一个问题：如果并发的请求数量非常多，但每个线程执行的时间很短，这样就会频繁的创建和销毁线程，如此一来会大大降低系统的效率。可能出现服务器在为每个请求创建新线程和销毁线程上花费的时间和消耗的系统资源要比处理实际的用户请求的时间和资源更多。

线程池为线程生命周期的开销和资源不足问题提供了解决方案。通过对多个任务重用线程，线程创建的开销被分摊到了多个任务上。
什么时候使用线程池？
单个任务处理时间比较短
需要处理的任务数量很大
线程池优势
重用存在的线程，减少线程创建，消亡的开销，提高性能提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

~~理论大概说了下，接下来是源码解析：

/**
*ctl 是对线程池的运行状态和线程池中有效线程的数量进行控制的一个字段， 它包含两
*部分的信息: 线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)，这
*里可以看到，使用了Integer类型来保存，高3位保存runState，低29位保存
*workerCount。COUNT_BITS 就是29，CAPACITY就是1左移29位减1（29个1），这个常
*量表示workerCount的上限值，大约是5亿。
*/
 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;
    //下面是线程池的5中运行状态
    // 高三位为111，能够接收新任务，以及对已添加的任务进行处理。
    private static final int RUNNING    = -1 << COUNT_BITS;
	//高3位为000，不接收新任务，但能处理已添加的任务
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
	//高3位为001,不接收新任务，不处理已添加的任务，并且会中断正在处理的任务
    private static final int STOP       =  1 << COUNT_BITS;
	//高3位为010,当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态,会执行钩子函数terminated()
    private static final int TIDYING    =  2 << COUNT_BITS;
	//高3位为011,线程池彻底终止，就变成TERMINATED状态
    private static final int TERMINATED =  3 << COUNT_BITS;

	//获取运行状态
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
	//获取活动线程数；
    private static int workerCountOf(int c)  { return c & CAPACITY; }
	//获取运行状态和活动线程数的值。
    private static int ctlOf(int rs, int wc) { return rs | wc; }
    //获取运行状态
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
	//获取活动线程数；
    private static int workerCountOf(int c)  { return c & CAPACITY; }
	//获取运行状态和活动线程数的值。
    private static int ctlOf(int rs, int wc) { return rs | wc; }
	//线程池已执行与未执行的任务总数
	public long getTaskCount() 
     //已完成的任务数
	public long getCompletedTaskCount() 
    //线程池当前的线程数   
    public int getPoolSize() 
	//线程池中正在执行任务的线程数量
    public int getActiveCount() 

线程池状态切换图

/**
	*  线程池的创建方法
	*/
	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;
    }

参数解释
corePoolSize
线程池中的核心线程数，当提交一个任务时，线程池创建一个新线程执行任务，直到当前线程数等于corePoolSize；如果当前线程数为corePoolSize，继续提交的任务被保存到阻塞队列中，等待被执行；如果执行了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有核心线程。
maximumPoolSize
线程池中允许的最大线程数。如果当前阻塞队列满了，且继续提交任务，则创建新的线程执行任务，前提是当前线程数小于maximumPoolSize；
keepAliveTime
线程池维护线程所允许的空闲时间。当线程池中的线程数量大于corePoolSize的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了keepAliveTime；
unit
keepAliveTime的单位；
workQueue
用来保存等待被执行的任务的阻塞队列，且任务必须实现Runable接口，在JDK中提供
了如下阻塞队列：
1、ArrayBlockingQueue：基于数组结构的有界阻塞队列，按FIFO排序任务；
2、LinkedBlockingQuene：基于链表结构的阻塞队列，按FIFO排序任务，吞吐量通常要高于ArrayBlockingQuene；
3、SynchronousQuene：一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQuene；
4、priorityBlockingQuene：具有优先级的无界阻塞队列；
threadFactory
它是ThreadFactory类型的变量，用来创建新线程。默认使用Executors.defaultThreadFactory() 来创建线程。使用默认的ThreadFactory来创建线程时，会使新创建的线程具有相同的NORM_PRIORITY优先级并且是非守护线程，同时也设置了线程的名称。
handler
线程池的饱和策略，当阻塞队列满了，且没有空闲的工作线程，如果继续提交任务，必须采取一种策略处理该任务，线程池提供了4种策略：
1、AbortPolicy：直接抛出异常，默认策略；
2、CallerRunsPolicy：用调用者所在的线程来执行任务；
3、DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
4、DiscardPolicy：直接丢弃任务；
上面的4种策略都是ThreadPoolExecutor的内部类。
当然也可以根据应用场景实现RejectedExecutionHandler接口，自定义饱和策略，如
记录日志或持久化存储不能处理的任务。
execute方法解读

   public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
		//clt记录着runState和workerCount
        int c = ctl.get();
		//workerCountOf方法取出低29位的值，表示当前活动的线程数；如果当前活动线程数小于corePoolSize,则新建一个线程放入线程池中；并把任务添加到该线程中。
        if (workerCountOf(c) < corePoolSize) {
		// addWorker中的第二个参数表示限制添加线程的数量是根据corePoolSize来判断还是maximumPoolSize来判断；如果为true，根据corePoolSize来判断；如果为false，则根据maximumPoolSize来判断
            if (addWorker(command, true))
                return;
	    //如果添加失败，则重新获取ctl值
            c = ctl.get();
        }
		//如果当前线程池是运行状态并且任务添加到队列成功
        if (isRunning(c) && workQueue.offer(command)) {
			// 重新获取ctl值
            int recheck = ctl.get();
			// 再次判断线程池的运行状态，如果不是运行状态，由于之前已经把command添加到workQueue中了， 这时需要移除该command 
            if (! isRunning(recheck) && remove(command))
				// 执行过后通过handler使用拒绝策略对该任务进行处理，整个方法返回
                reject(command);
				//获取线程池中的有效线程数，如果数量是0，则执行addWorker方法
                // 第一个参数为null，表示在线程池中创建一个线程，但不去启动；
                // 第二个参数为false，将线程池的有限线程数量的上限设置为maximumPoolSize，添加线程时根据maximumPoolSize来判断；
               //如果判断workerCount大于0，则直接返回，在workQueue中新增的command会在将来的某个时刻被执行。
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
		//执行到这里，有两种情况：1. 线程池已经不是RUNNING状态；2. 线程池是RUNNING状态，但workerCount >= corePoolSize并且workQueue已满。
		//这时，再次调用addWorker方法，但第二个参数传入为false，将线程池的有限线程数量的上限设置为maximumPoolSize；如果失败则拒绝该任务
        else if (!addWorker(command, false))
            reject(command);
    }

addWorker方法解读

	/**
	*addWorker方法的主要工作是在线程池中创建一个新的线程并执行，firstTask参数 用
    *于指定新增的线程执行的第一个任务，core参数为true表示在新增线程时会判断当前活动线
    *程数是否少于corePoolSize，false表示新增线程前需要判断当前活动线程数是否少于maximumPoolSize
	*/
	private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
			//获取ctl值
            int c = ctl.get();
			//获取运行状态
            int rs = runStateOf(c);

            //* 如果rs >= SHUTDOWN，则表示此时不再接收新任务；如果firstTask为空，并且workQueue也为空，则返回false，因为队列中已经没有任务了，不需要再添加线程了
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
				//获取线程池中的有效线程数
                int wc = workerCountOf(c);
				// 如果wc超过CAPACITY，也就是ctl的低29位的最大值，或者core是true,wc超过了corePoolSize,或者core为false，wc超过了maximumPoolSize，则返回false
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
				 // 尝试增加workerCount，如果成功，则跳出第一个for循环
                if (compareAndIncrementWorkerCount(c))
                    break retry;
				//如果增加workerCount失败，则重新获取ctl的值
                c = ctl.get();  
				// 如果当前的运行状态不等于rs，说明状态已被改变，返回第一个for循环继续执行
                if (runStateOf(c) != rs)
                    continue retry;
            }
        }

        boolean workerStarted = false
        boolean workerAdded = false;
        Worker w = null;
        try {
			// 根据firstTask来创建Worker对象
            w = new Worker(firstTask);
			// 每一个Worker对象都会创建一个线程
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    int rs = runStateOf(ctl.get());
              // rs < SHUTDOWN表示是RUNNING状态；
              // 如果rs是RUNNING状态或者rs是SHUTDOWN状态并且firstTask为null，向线程池中添加线程。
              // 因为在SHUTDOWN时不会在添加新的任务，但还是会执行workQueue中的任务
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
							// workers是一个HashSet
                        workers.add(w);
						//largestPoolSize记录着线程池中出现过的最大线程数量
                        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;
    }

Worker类

	/**
		*线程池中的每一个线程被封装成一个Worker对象，ThreadPool维护的其实就是一组Worker对象，Worker类继承了AQS实现了Runnable接口
		*/
	   private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
        /**
         * This class will never be serialized, but we provide a
         * serialVersionUID to suppress a javac warning.
         */
        private static final long serialVersionUID = 6138294804551838833L;

        /** Thread this worker is running in.  Null if factory fails. 调用构造方法时通过ThreadFactory来创建的线程，是用来处理任务的线程 */
        final Thread thread;
        /** Initial task to run.  Possibly null.  firstTask用它来保存传入的任务；*/
        Runnable firstTask;
        /** Per-thread task counter */
        volatile long completedTasks;

        /**
         * Creates with given first task and thread from ThreadFactory.
         * @param firstTask the first task (null if none)
		 *  通过getThreadFactory().newThread(this);来新建一个线程，newThread方法传入的参数是this
		 *  因为Worker本身继承了Runnable接口是一个线程，所以一个Worker对象在启动的时会调用Worker类中的run方法
         */
        Worker(Runnable firstTask) {
			//state变量设置为-1,因为AQS中默认的state是0，如果刚创建了一个Worker对象，还没有执行任务时，这时就不应该被中断
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

        /** Delegates main run loop to outer runWorker  */
        public void run() {
            runWorker(this);
        }

        // Lock methods
        //
        // The value 0 represents the unlocked state.
        // The value 1 represents the locked state.

        protected boolean isHeldExclusively() {
            return getState() != 0;
        }
		/**
		*1. lock方法一旦获取了独占锁，表示当前线程正在执行任务中,正在执行任务，则不应该中断线程，如果线程不是独占锁状态，说明是空闲，可以中断
        *2. 线程池在执行shutdown方法或tryTerminate方法时会调用interruptIdleWorkers方法来中断空闲的线程，interruptIdleWorkers方法会使用tryLock方法来判断线程池中的线程是否是空闲状态
        *3. 设置为不可重入是因为我们不希望调用像setCorePoolSize这样的线程池控制方法时重新获取锁。如果使用ReentrantLock，它是可重入的，这样如果在任务中调用了如setCorePoolSize这类线程池控制的方法，会中断正在运行的线程。
		*/
        protected boolean tryAcquire(int unused) {
			//cas修改state，不可重入
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        protected boolean tryRelease(int unused) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        public void lock()        { acquire(1); }
        public boolean tryLock()  { return tryAcquire(1); }
        public void unlock()      { release(1); }
        public boolean isLocked() { return isHeldExclusively(); }

        void interruptIfStarted() {
            Thread t;
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }
    }

runWorker方法

	/**
		*Worker类中的run方法调用了ThreadPoolExecutor中的runWorker方法
		*/
	   final void runWorker(Worker w) {
		   //获取当前线程
        Thread wt = Thread.currentThread();
		  //获取第一个任务
        Runnable task = w.firstTask;
        w.firstTask = null;
		//tryAcquire方法是根据state是否是0来判断的,Worker构造中将state设置为-1是为了禁止在执行任务前对线程进行中断。因此在runWorker方法中会先调用Worker对象的unlock方法将state设置为0。
        w.unlock(); // allow interrupts
		//此变量表示在执行过程中是否出现了异常
        boolean completedAbruptly = true;
        try {
			// 如果task为空，则通过getTask来获取任务
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // 如果线程池正在停止，那么要保证当前线程是中断状态；如果不是的话，则要保证当前线程不是中断状态；
             
                if ((runStateAtLeast(ctl.get(), STOP) ||
				//Thread.interrupted()来判断是否中断是为了确保在RUNNING 或者SHUTDOWN 状态时线程是非中断状态的,因为此方法会复位中断的状态。
                     (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 {
			//  task = null;线程工作退出方法
            processWorkerExit(w, completedAbruptly);
        }
    }

getTask方法

	/**
	*从阻塞队列获取任务
	*/
	  private Runnable getTask() {
		  //timeOut变量的值表示上次从阻塞队列中取任务时是否超时
        boolean timedOut = false; // Did the last poll() time out?

        for (;;) {
			//clt记录着runState和workerCount
            int c = ctl.get();
		    //获取运行状态
            int rs = runStateOf(c);
			//如果线程池是非RUNNING状态,线程池是否STOP,阻塞队列是否为空，	
            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
				//cas进行ctl的值进行减一，并且返回null
                decrementWorkerCount();
                return null;
            }
			//获取活动线程数；
            int wc = workerCountOf(c);

            // Are workers subject to culling?
			//对于超过核心线程数量的这些线程，需要进行超时控制,allowCoreThreadTimeOut默认是false，也就是核心线程不允许进行超时
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
			//timed && timedOut 如果为true，表示当前操作需要进行超时控制，并且上次从阻塞队列中获取任务发生了超时
            if ((wc > maximumPoolSize || (timed && timedOut))
				//如果有效线程数量大于1，或者阻塞队列是空的，那么尝试将workerCount减1；
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
				//timed为true，通过阻塞队列的poll方法进行超时控制，如果在keepAliveTime时间内没有获取到任务，则返回null；
				//否则通过take方法，如果这时队列为空，则take方法会阻塞直到队列不为空。
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
					//如果 r == null，说明已经超时，timedOut设置为true
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
				//如果获取任务时当前线程发生了中断，则设置timedOut为false并返回循环重试
                timedOut = false;
            }
        }
    }

processWorkerExit方法

private void processWorkerExit(Worker w, boolean completedAbruptly) {
		//如果completedAbruptly值为true，则说明线程执行时出现了异常，需要将workerCount减1；
        if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
            decrementWorkerCount();

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
			//统计完成的任务数
            completedTaskCount += w.completedTasks;
			// 从workers中移除，也就表示着从线程池中移除了一个工作线程
            workers.remove(w);
        } finally {
            mainLock.unlock();
        }
     // 根据线程池状态进行判断是否结束线程池
        tryTerminate();
        int c = ctl.get();
		//当线程池是RUNNING或SHUTDOWN状态时，如果worker是异常结束，那么会直接addWorker
        if (runStateLessThan(c, STOP)) {
            if (!completedAbruptly) {
				//如果allowCoreThreadTimeOut=true，并且等待队列有任务，至少保留一个worker；反之，最少保留corePoolSize个Worker
                int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
                if (min == 0 && ! workQueue.isEmpty())
                    min = 1;
                if (workerCountOf(c) >= min)
                    return; // replacement not needed
            }
            addWorker(null, false);
        }
    }

总结