线程池及Executor框架

1. 线程的实现方式

讲线程池之前我们先看一下线程的实现方式： Thread，Runnable，Callable

// 实现Runnable接口的类将被Thread执行，表示一个基本的任务
public interface Runnable {
    // run方法就是它所有的内容，就是实际执行的任务
    public abstract void run();
}

//Callable同样是任务，与Runnable接口的区别在于它接收泛型，同时它执行任务后带有返回内容
public interface Callable<V> {
    // 相对于run方法的带有返回值的call方法
    V call() throws Exception;
}

2. 线程池介绍

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

2.1 线程池优势

（1）降低资源的消耗。通过重用存在的线程，减少线程创建，消亡的开销，提高性能。

（2）提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。

（3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

2.2 线程池的实现原理

ThreadPoolExecutor执行示意图 ：

ThreadPoolExecutor执行execute方法分下面4种情况：
（1）如果当前运行的线程少于corePoolSize，则创建新线程来执行任务（注意，执行这一步骤需要获取全局锁）。
（2）如果运行的线程等于或多于corePoolSize，则将任务加入BlockingQueue。
（3）如果无法将任务加入BlockingQueue（队列已满），则创建新的线程来处理任务（注意，执行这一步骤需要取全局锁）。
（4）如果创建新线程将使当前运行的线程超出maximumPoolSize，任务将被拒绝，并调用RejectedExecutionHandler.rejectedExecution()方法。

2.3  线程池的创建(ThreadPoolExecutor)

public ThreadPoolExecutor(int corePoolSize,
			  int maximumPoolSize,
			  long keepAliveTime,
			  TimeUnit unit,
			  BlockingQueue<Runnable> workQueue,
			  ThreadFactory threadFactory,
			  RejectedExecutionHandler handler)   

• corePoolSize（线程池的基本大小）：当提交一个任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小时就不再创建。如果调用了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有基本线程。
• maximumPoolSize：线程池中允许的最大线程数。如果当前阻塞队列满了，且继续提交任务，则创建新的线程执行任务，前提是当前线程数小于maximumPoolSize；
• keepAliveTime：线程池维护线程所允许的空闲时间。当线程池中的线程数量大于corePoolSize的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了keepAliveTime；
• unit：keepAliveTime的单位。
• workQueue：用来保存等待被执行的任务的阻塞队列，且任务必须实现Runable接口，在JDK中提供了如下阻塞队列：

　　　　a. ArrayBlockingQueue：基于数组结构的有界阻塞队列，按FIFO排序任务；

　　　 b. LinkedBlockingQuene：基于链表结构的阻塞队列，按FIFO排序任务，吞吐量通常要高于ArrayBlockingQuene；
　　    c. SynchronousQuene：一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQuene；
　　 　d. priorityBlockingQuene：具有优先级的无界阻塞队列；

• threadFactory：它是ThreadFactory类型的变量，用来创建新线程。默认使用Executors.defaultThreadFactory() 来创建线程。使用默认的ThreadFactory来创建线程时，会使新创建的线程具有相同的NORM_PRIORITY优先级并且是非守护线程，同时也设置了线程的名称。
• handler：线程池的饱和策略，当阻塞队列满了，且没有空闲的工作线程，如果继续提交任务，必须采取一种策略处理该任务，线程池提供了4种策略：

　　　　a.  AbortPolicy：直接抛出异常，默认策略；
　　　　b. CallerRunsPolicy：用调用者所在的线程来执行任务；
　　　　c.  DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
　　　　d. DiscardPolicy：直接丢弃任务；
　　　　上面的4种策略都是ThreadPoolExecutor的内部类。当然也可以根据应用场景实现RejectedExecutionHandler接口，自定义饱和策略，如记录日志或持久化存储不能处理的任务。

public class PolicySample {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                3,
                5,
                3,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(2),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy());
        Future<String> future = null;
        List<Future<String>> list = new ArrayList<Future<String>>();

        for (int i=0;i<20;i++){
            list.add(pool.submit(new CallTask()));
        }

        if(!list.isEmpty()){
            for (Future<String> f : list){
                System.out.println(f.get());
            }
        }
    }
}

2.4 线程池的5种状态

（1）RUNNING
　　a. 状态说明：线程池处在RUNNING状态时，能够接收新任务，以及对已添加的任务进行处理。
　　b. 状态切换：线程池的初始化状态是RUNNING。换句话说，线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0！
（2）SHUTDOWN
　　a. 状态说明：线程池处在SHUTDOWN状态时，不接收新任务，但能处理已添加的任务。
　　b. 状态切换：调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN。
（3）STOP
　　a. 状态说明：线程池处在STOP状态时，不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。
　　b. 状态切换：调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) -> STOP。
（4）TIDYING
　　a. 状态说明：当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。
　　b. 状态切换：当线程池在SHUTDOWN状态下，阻塞队列为空并且线程池中执行的任务也为空时，就会由 SHUTDOWN -> TIDYING。 当线程池在STOP状态下，线程池中执行的任务为空时，就会由STOP -> TIDYING。
（5）TERMINATED
　　a.  状态说明：线程池彻底终止，就变成TERMINATED状态。
　　b. 状态切换：线程池处在TIDYING状态时，执行完terminated()之后，就会由 TIDYING -> TERMINATED。
　　进入TERMINATED的条件如下：

　　　　I. 线程池不是RUNNING状态；

　　　　II. 线程池状态不是TIDYING状态或TERMINATED状态；

　　　　III. 如果线程池状态是SHUTDOWN并且workerQueue为空；

　　　　IV. workerCount为0；

　　　　V. 设置TIDYING状态成功。

 

 

3. Executor框架

Executor接口是线程池框架中最基础的部分，定义了一个用于执行Runnable的execute方法。
下图为它的继承与实现

 

 从图中可以看出Executor下有一个重要子接口ExecutorService，其中定义了线程池的具体行为：

• execute（Runnable command）：履行Ruannable类型的任务,
• submit（task）：可用来提交Callable或Runnable任务，并返回代表此任务的Future对象
• shutdown（）：在完成已提交的任务后封闭办事，不再接管新任务,
• shutdownNow（）：停止所有正在履行的任务并封闭办事。
• isTerminated（）：测试是否所有任务都履行完毕了。
• isShutdown（）：测试是否该ExecutorService已被关闭。

4. 线程池的源码分析

4.1 线程池的重点属性

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;

　　ctl 是对线程池的运行状态和线程池中有效线程的数量进行控制的一个字段， 它包含两部分的信息: 线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)，这里可以看到，使用了Integer类型来保存，高3位保存runState，低29位保存workerCount。COUNT_BITS 就是29，CAPACITY就是1左移29位减1（29个1），这个常量表示workerCount的上限值，大约是5亿。

4.2 ThreadPoolExecutor 线程池的 execute 方法

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

简单来说，在执行execute()方法时如果状态一直是RUNNING时的执行过程如下：
　　a. 如果workerCount < corePoolSize，则创建并启动一个线程来执行新提交的任务；
　　b. 如果workerCount >= corePoolSize，且线程池内的阻塞队列未满，则将任务添加到该阻塞队列中；
　　c. 如 果 workerCount >= corePoolSize && workerCount <maximumPoolSize，且线程池内的阻塞队列已满，则创建并启动一个线程来执行新提交的任务；
　　d. 如果workerCount >= maximumPoolSize，并且线程池内的阻塞队列已满, 则根据拒绝策略来处理该任务, 默认的处理方式是直接抛异常。

　　这里要注意一下addWorker(null, false);，也就是创建一个线程，但并没有传入任务，因为任务已经被添加到workQueue中了，所以worker在执行的时候，会直接从workQueue中获取任务。所以，在workerCountOf(recheck) == 0时执行addWorker(null, false);也是为了保证线程池在RUNNING状态下必须要有一个线程来执行任务。

4.3 execute 方法中的 addWork(Runnable firstTask, boolean core) 方法

 addWork 方法主要功能是在线程池中创建一个新的线程并执行，firstTask 参数用于指定新增的线程执行的第一个任务，core 参数为 true 表示在新增线程时会判断当前活动线程数是否少于 corePoolSize，false表示新增线程前需要判断当前活动线程数是否少于maximumPoolSize。

private boolean addWorker(Runnable firstTask, boolean core) {
	retry:
	
	/** 1. 增加workerCount **/
	for (;;) {
		int c = ctl.get();
		
		// 获取当前线程池运行状态
		int rs = runStateOf(c);
		
		/*
		* 如果rs >= SHUTDOWN，则表示此时不再接收新任务；
		* (1) rs >= SHUTDOWN 且 rs != SHUTDOWN（即rs > SHUTDOWN），则返回false；
		* (2) rs >= SHUTDOWN 且 firsTask不为空，则返回false；
		* (3) rs >= SHUTDOWN 且 阻塞队列为空，返回false; 因为队列中已经没有任务了，不需要再添加线程了；
		*/
		// Check if queue empty only if necessary.
		if (rs >= SHUTDOWN && !(rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty()))
			return false;
		for (;;) {
			// 获取线程数
			int wc = workerCountOf(c);
			
			/* 如果wc超过CAPACITY，也就是ctl的低29位的最大值（二进制是29个1），返回false；
			* 这里的core是addWorker方法的第二个参数，
			* 若core为true表示根据corePoolSize来比较；
			* 若core为false则根据maximumPoolSize来比较。
			*/
			if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize))
				return false;
				
			// 尝试增加workerCount，如果成功，则跳出第一个for循环
			if (compareAndIncrementWorkerCount(c))
				break retry;
			
			// 如果增加workerCount失败，则重新获取ctl的值
			c = ctl.get(); // Re­read ctl// 如果当前的运行状态不等于rs，说明状态已被改变，返回第一个for循环继续执行
			if (runStateOf(c) != rs)
				continue retry;
		}
	}
	
	/** 2. 创建Work，并启动线程 */
	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());
				
				/*(1) rs < SHUTDOWN表示是RUNNING状态，则向线程池中添加线程；
				* (2) 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);
					int s = workers.size();
					
					// largestPoolSize记录着线程池中出现过的最大线程数量if (s > largestPoolSize)
					largestPoolSize = s;
					workerAdded = true;
				}
			} finally {
				mainLock.unlock();
			}
			if (workerAdded) {
				// 启动线程
				t.start();
				workerStarted = true;
			}
		}
	} 
	finally {
		if (! workerStarted)
			addWorkerFailed(w);
	}
	return workerStarted;
}

t.start() 方法实际上执行的 Worker 类 中的 run() 方法， run() 方法又调用了 Worker 类的 runWorker(this) 方法；

 

4.4 Worker 类 

　　线程池中的每一个线程被封装成一个Worker对象，ThreadPool维护的其实就是一组Worker对象，请参见JDK源码。
　　Worker类继承了AQS，并实现了Runnable接口，注意其中的firstTask和thread属性：firstTask用它来保存传入的任务；thread是在调用构造方法时通过ThreadFactory来创建的线程，是用来处理任务的线程。
　　在调用构造方法时，需要把任务传入，这里通 过getThreadFactory().newThread(this);来新建一个线程，newThread方法传入的参数是this，因为Worker本身继承了Runnable接口，也就是一个线程，所以一个Worker对象在启动的时候会调用Worker类中的run方法。

　　Worker继承自AQS，用于判断线程是否空闲以及是否可以被中断。

（1）Worker继承了AQS，使用AQS来实现独占锁的功能。为什么不使用ReentrantLock来实现呢？

可以看到tryAcquire方法，它是不允许重入的，而ReentrantLock是允许重入的：
　　a. lock方法一旦获取了独占锁，表示当前线程正在执行任务中；
　　b. 如果正在执行任务，则不应该中断线程；
　　c. 如果该线程现在不是独占锁的状态，也就是空闲的状态，说明它没有在处理任务，这时可以对该线程进行中断；
　　d. 线程池在执行shutdown方法或tryTerminate方法时会调用interruptIdleWorkers方法来中断空闲的线程，interruptIdleWorkers方法会使用tryLock方法来判断线程池中的线程是否是空闲状态；
　　e. 之所以设置为不可重入，是因为我们不希望任务在调用像setCorePoolSize这样的线程池控制方法时重新获取锁。如果使用ReentrantLock，它是可重入的，这样如果在任务中调用了如setCorePoolSize这类线程池控制的方法，会中断正在运行的线程。

（2）在构造方法中执行了setState(-1)，把state变量设置为-1，为什么这么做呢？
因为AQS中默认的state是0，如果刚创建了一个Worker对象，还没有执行任务时，这时就不应该被中断，可以看tryAquire方法：

protected boolean tryAcquire(int unused) {
	//CAS操作成功的前提是state==0；若state==-1，是中断不了线程的
    if (compareAndSetState(0, 1)) {
		setExclusiveOwnerThread(Thread.currentThread());
		return true;
    }
	return false;
}

tryAcquire方法是根据state是否是0来判断的，所以，setState(-1);将state设置为-1是为了禁止在执行任务前对线程进行中断。

也因为如此，在 runWorker 方法中会先调用Worker对象的unlock方法将state设置为0。

（3）Worker 类的 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 {
		// 如果task为空，则通过getTask来获取任务
		while (task != null || (task = getTask()) != null) {
			w.lock();
			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 {
		processWorkerExit(w, completedAbruptly);
	}
}

① 处的 if 判断，目的是：

• 如果线程池正在停止，那么要保证当前线程是中断状态；

• 如果不是的话，则要保证当前线程不是中断状态；

因为在执行该if语句期间可能也执行了shutdownNow方法，shutdownNow方法会把状态设置为STOP，回顾一下STOP状态：不能接受新任务，也不处理队列中的任务，会中断正在处理任务的线程。在线程池处于RUNNING 或 SHUTDOWN 状态时，调用 shutdownNow() 方法会使线程池进入到该状态。

runwoker 方法 的执行过程：

　　a. while循环不断地通过getTask()方法获取任务；

　　b. getTask()方法从阻塞队列中取任务；

　　c. 如果线程池正在停止，那么要保证当前线程是中断状态，否则要保证当前线程不是中断状态；

　　d. 调用task.run()执行任务；

　　e. 如果task为null则跳出循环，执行processWorkerExit()方法；

　　f. runWorker方法执行完毕，也代表着Worker中的run方法执行完毕，销毁线程。

这里的 beforeExecute 方法和 afterExecute 方法在 ThreadPoolExecutor 类中是空的，留给子类来实现。

completedAbruptly变量来表示在执行任务过程中是否出现了异常，在processWorkerExit方法中会对该变量的值进行判断。

（4）runWorker 方中的 getTask() 方法  

getTask方法用来从阻塞队列中取任务，代码如下 ：

private Runnable getTask() {

	// timeOut变量的值表示上次从阻塞队列中取任务时是否超时
	boolean timedOut = false; // Did the last poll() time out?
	for (;;) {
		int c = ctl.get();
		int rs = runStateOf(c); 
		
		/* 1.若线程状态为STOP之后，或线程状态为SHUTDOWN之后时队列中没有任务，则将workerCount减1并返回null，不允许再向阻塞队列中添加任务*/
		if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty()))
		{
			decrementWorkerCount(); // 工作数减1
			return null;
		}
		int wc = workerCountOf(c);
		
		/* timed变量用于判断是否需要进行超时控制。
		* allowCoreThreadTimeOut默认是false，也就是核心线程不允许进行超时；
		* 但是对于超过核心线程数量的这些线程，需要进行超时控制*/
		boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
		
		/* 2. wc > maximumPoolSize的情况是因为可能在此方法执行阶段同时执行了setMaximumPoolSize方法；
		* timed && timedOut 如果为true，表示当前操作需要进行超时控制，并且上次从阻塞队列中获取任务发生了超时；
		* 接下来判断，如果有效线程数量大于1，或者阻塞队列是空的，那么尝试将workerCount减1；
		* 如果减1失败，则返回重试。
		* 如果wc == 1时，也就说明当前线程是线程池中唯一的一个线程了。
		*/
		if ((wc > maximumPoolSize || (timed && timedOut)) && (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)
				return r;
			
			// 如果 r == null，说明已经超时，timedOut设置为true
			timedOut = true;
		} 
		catch (InterruptedException retry) {
			// 如果获取任务时当前线程发生了中断，则设置timedOut为false并返回循环重试
			timedOut = false;
		}
	}
}

第2个 if 判断的目的是控制线程池的有效线程数。

　　由上文中的分析可以知道，在执行execute方法时，如果当前线程池的线程数量超过了corePoolSize且小于maximumPoolSize，并且workQueue已满时，则可以增加工作线程，但这时如果超时没有获取到任务，也就是timedOut为true的情况，说明workQueue已经为空了，也就说明了当前线程池中不需要那么多线程来执行任务了，可以把多于corePoolSize数量的线程销毁掉，保持线程数量在corePoolSize即可。

什么时候会销毁？
　　当然是runWorker方法执行完之后，也就是Worker中的run方法执行完，由JVM自动回收。
在 runWorker 方法的循环语句中，getTask方法返回null时，在runWorker方法中会跳出while循环，然后会执行finally语句中的 processWorkerExit方法，代码如下：

private void processWorkerExit(Worker w, boolean completedAbruptly) {

	// 如果completedAbruptly值为true，则说明线程执行时出现了异常，需要将workerCount减1；
	// 如果线程执行时没有出现异常，说明在getTask()方法中已经已经对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；
	* 如果allowCoreThreadTimeOut=true，并且等待队列有任务，至少保留一个 worker；
	* 如果allowCoreThreadTimeOut=false，workerCount不少于corePoolSize。
	*/
	if (runStateLessThan(c, STOP)) {
		if (!completedAbruptly) {
			int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
			if (min == 0 && ! workQueue.isEmpty())
				min = 1;
			if (workerCountOf(c) >= min)
				return; // replacement not needed
		}
		addWorker(null, false);
	}
}

processWorkerExit执行完之后，工作线程被销毁;

总结：以上就是整个工作线程的生命周期，从execute方法开始，Worker使用ThreadFactory创建新的工作线程，runWorker通过getTask获取任务，然后执行任务，如果getTask返回null，进入processWorkerExit方法，整个线程结束，如图所示：

 

可以尝试者自己写一个简单的线程池！！！