Java并发---- Executor并发框架--ThreadToolExecutor类详解(execute方法，关闭方法)

1、构造方法

请参考上篇文章：http://blog.csdn.net/ochangwen/article/details/53044733

2、源码详解

线程池能够复用线程，减少线程创建，销毁，恢复等状态切换的开销，提高程序的性能。一个线程池管理了一组工作线程，同时它还包括了一个用于放置等待执行的任务的队列。

ThreadPoolExecutor类中定义了一些与线程状态与活动线程数相关的一些变量，如下：

线程池内部有一些状态，先来了解下这些状态的机制。以下用代码注释的方式来解释其中的含义。

[java] view plain copy

1. /* 
2. 这个是用一个int来表示workerCount和runState的，其中runState占int的高3位， 
3. 其它29位为workerCount的值。 
4.  
5. workerCount:当前活动的线程数； 
6. runState：线程池的当前状态。 
7.  
8. 用AtomicInteger是因为其在并发下使用compareAndSet效率非常高； 
9. 当改变当前活动的线程数时只对低29位操作，如每次加一减一，workerCount的值变了， 
10. 但不会影响高3位的runState的值。当改变当前状态的时候，只对高3位操作，不会改变低29位的计数值。 
11. 这里有一个假设，就是当前活动的线程数不会超过29位能表示的值，即不会超过536870911， 
12. 就目前以及可预见的很长一段时间来讲，这个值是足够用了 
13. */  
14. private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));  
15.   
16. //COUNT_BITS，就是用来表示workerCount占用一个int的位数，其值为前面说的29  
17. private static final int COUNT_BITS = Integer.SIZE - 3;  
18.   
19. /* 
20. CAPACITY为29位能表示的最大容量，即workerCount实际能用的最大值。 
21. 其值的二进制为：00011111111111111111111111111111（占29位，29个1） 
22. */  
23. private static final int CAPACITY   = (1 << COUNT_BITS) - 1;  
24.   
25. /* 
26. 以下常量是线程池的状态，状态存储在int的高3位，所以要左移29位。 
27. 腾出的低29位来表示workerCount 
28. 注意，这5个状态是有大小关系的。RUNNING<shutdown<stop<tidying<terminated 当需要判断多个状态时，只需要用<或="">来判断就可以了 
29. */  
30.   
31. /* 
32. RUNNING的含义：线程池能接受新任务，并且可以运行队列中的任务 
33. -1的二进制为32个1，移位后为：11100000000000000000000000000000 
34. */  
35. private static final int RUNNING    = -1 << COUNT_BITS;  
36.   
37. /* 
38. SHUTDOWN的含义：不再接受新任务，但仍可以执行队列中的任务 
39. 0的二进制为32个0，移位后还是全0 
40. */  
41. private static final int SHUTDOWN   =  0 << COUNT_BITS;  
42.   
43. /* 
44. STOP的含义：不再接受新任务，不再执行队列中的任务，而且要中断正在处理的任务 
45. 1的二进制为前面31个0，最后一个1，移位后为：00100000000000000000000000000000 
46. */  
47. private static final int STOP       =  1 << COUNT_BITS;  
48.   
49. /* 
50. TIDYING的含义：所有任务均已终止，workerCount的值为0， 
51. 转到TIDYING状态的线程即将要执行terminated()钩子方法. 
52. 2的二进制为00000000000000000000000000000010 
53. 移位后01000000000000000000000000000000 
54. */  
55. private static final int TIDYING    =  2 << COUNT_BITS;  
56.   
57. /* 
58. TERMINATED的含义:terminated()方法执行结束. 
59. 3的二进制为00000000000000000000000000000011 
60. 移位后01100000000000000000000000000000 
61. */  
62. private static final int TERMINATED =  3 << COUNT_BITS;  

[java] view plain copy

1. 各状态之间可能的转变有以下几种：  
2. RUNNING -> SHUTDOWN  
3.     调用了shutdown方法，线程池实现了finalize方法，在里面调用了shutdown方法，因此shutdown可能是在finalize中被隐式调用的  
4. (RUNNING or SHUTDOWN) -> STOP  
5.     调用了shutdownNow方法  
6. SHUTDOWN -> TIDYING  
7.     当队列和线程池均为空的时候  
8. STOP -> TIDYING  
9.     当线程池为空的时候  
10. TIDYING -> TERMINATED  
11.     terminated()钩子方法调用完毕  

[java] view plain copy

1. /* 
2. 传入的参数为存储runState和workerCount的int值，这个方法用于取出runState的值。 
3. ~为按位取反操作，~CAPACITY值为：11100000000000000000000000000000， 
4. 再同参数做&操作，就将低29位置0了，而高3位还是保持原先的值，也就是runState的值 
5. */  
6. private static int runStateOf(int c)     { return c & ~CAPACITY; }  
7.   
8. /* 
9. 传入的参数为存储runState和workerCount的int值，这个方法用于取出workerCount的值。 
10. 因为CAPACITY值为：00011111111111111111111111111111，所以&操作将参数的高3位置0了， 
11. 保留参数的低29位，也就是workerCount的值。 
12. */  
13. private static int workerCountOf(int c)  { return c & CAPACITY; }  
14.   
15. /* 
16. 将runState和workerCount存到同一个int中，这里的rs就是runState， 
17. 是已经移位过的值，填充返回值的高3位，wc填充返回值的低29位 
18. */  
19. private static int ctlOf(int rs, int wc) { return rs | wc; }  

1、创建线程池并执行任务

接下来通过状态来看线程池的运行：

完成线程的创建后，

首先通过 submit 或者 execute 方法提交，实际submit 方法也是内部调用 execute方法；

submit方法的实现是在AbstractExecutorService类里，三种重载方法类似，

[java] view plain copy

1. public Future<?> submit(Runnable task) {  
2.     if (task == null) throw new NullPointerException();  
3.     RunnableFuture<Void> ftask = newTaskFor(task, null);  
4.     execute(ftask); //<span style="font-size:12px;">内部调用 execute方法</span>  
5.     return ftask;  
6. }  

execute方法是在ThreadPoolExecutor类里实现

[java] view plain copy

1. public void execute(Runnable command) {  
2.         if (command == null) // 任务为null,则抛出异常  
3.             throw new NullPointerException();  
4.   
5.         // 然后通过workerCountOf方法从ctl所表示的int值中提取出低29位的值，也就是当前活动的线程数。  
6.         int c = ctl.get();  
7.   
8.         /* 
9.         如果当前活动的线程数小于corePoolSize，则增加一个线程来执行新传入的任务。 
10.         什么概念？也就是说当池中的线程数小于corePoolSize的时候，不管池中的线程是否有空闲的， 
11.         每次调用该方法都去增加一个线程，直到池中的数目达到corePoolSize为止。 
12.          */  
13.         if (workerCountOf(c) < corePoolSize) {  
14.             /* 
15.              * addWorker()返回值表示： 
16.              * 1、true 表示需要检测当前运行的线程是否小于corePoolSize 
17.              * 2、false 表示需要检测当前运行的线程数量是否小于maxPoolSize 
18.              */  
19.             if (addWorker(command, true))  
20.                 return;   // 新线程创建成功,终止该方法的执行  
21.   
22.             c = ctl.get();   // 任务添加到线程失败,取出记录着runState和workerCount 的 ctl的当前值  
23.         }  
24.   
25.         /* 
26.          * 方法解释： 
27.          * isRunning(c) 当前线程池是否处于运行状态。源代码是通过判断c < SHUTDOWN 来确定返回值。 
28.          * 由于RUNNING才会接收新任务，且只有这个值-1才小于SHUTDOWN 
29.          * workQueue.offer(command) 任务添加到缓冲队列 
30.          */  
31.         if (isRunning(c) && workQueue.offer(command)) {  // 当前线程处于运行状态且成功添加到缓冲队列  
32.             int recheck = ctl.get();  
33.   
34.             /* 
35.              * 如果 线程池已经处于非运行状态,则从缓冲队列中移除任务然后采用线程池指定的策略拒绝任务 
36.              * 如果 线程池中任务数量为0,则通过addWorker(null, false)尝试新建一个线程,新建线程对应的任务为null 
37.              */  
38.             if (! isRunning(recheck) && remove(command))  
39.                 reject(command);  
40.             else if (workerCountOf(recheck) == 0)   // 得到活动线程数为0  
41.                 addWorker(null, false);  
42.         }  
43.   
44.         /* 
45.          * 当不满足以下两个条件时执行如下代码： 
46.          *  1. 当前线程池并不处于Running状态 
47.          *  2. 当前线程池处于Running状态,但是缓冲队列已经满了 
48.          */  
49.         else if (!addWorker(command, false))  
50.             reject(command);   // 采用线程池指定的策略拒绝任务  
51.     }  
52.   
53.     private static int runStateOf(int c)     { return c & ~CAPACITY; }  
54.     private static int workerCountOf(int c)  { return c & CAPACITY; }  
55.     private static int ctlOf(int rs, int wc) { return rs | wc; }  
56.     private static boolean isRunning(int c) {  
57.         return c < SHUTDOWN;  
58.     }  

当前活动的线程小于corePoolSize了，那么等于和大于corePoolSize怎么处理呢？     

1>  当前活动的线程数量 >= corePoolSize 的时候，都是优先添加到队列中，直到队列满了才会去创建新的线程，在这里第20行的if语句已经体现出来了。这里利用了&&的特性，只有当第一个条件会真时才会去判断第二个条件，第一个条件是isRunning()，判断线程池是否处于RUNNING状态，因为只有在这个状态下才会接受新任务，否则就拒绝，如果正处于RUNNING状态，那么就加入队列，如果加入失败可能就是队列已经满了，这时候直接执行第29行。　　

2> 在execute()方法中，当 当前活动的线程数量 < corePoolSize 时，会执行addWorker()方法，关于addWorker()，它是用来直接新建线程用的，之所以叫addWorker而不是addThread是因为在线程池中，所有的线程都用一个Worker对象包装着，来看一下这个方法：

接下来介绍上面提到的addWorker方法，方法实现如下：

[java] view plain copy

1.  private static int runStateOf(int c)     { return c & ~CAPACITY; }  
2.   
3.     //使用原子的compareAndSet来替换旧值。但并不保证成功，若成功，该方法返回true；若失败，则返回false  
4.     private boolean compareAndIncrementWorkerCount(int expect) {  
5.         return ctl.compareAndSet(expect, expect + 1);  
6.     }  
7.   
8.     private final ReentrantLock mainLock = new ReentrantLock();  
9.   
10.     /** 
11.      * 创建并执行新线程 
12.      * @param firstTask 用于指定新增的线程执行的第一个任务 
13.      * @param core true表示在新增线程时会判断当前活动线程数是否少于corePoolSize， 
14.      *             false表示新增线程前需要判断当前活动线程数是否少于maximumPoolSize。 
15.      * @return  是否成功新增一个线程 
16.      */  
17.     private boolean addWorker(Runnable firstTask, boolean core) {  
18.         retry:  // 标签，写代码时避免使用标签。  
19.         for (;;) {  
20.             int c = ctl.get();     // 获取记录着runState和workCount的int变量的当前值  
21.             int rs = runStateOf(c); // 取出当前线程池运行的状态值  
22.   
23.             /* 
24.             这个条件代表着以下几个情景，就直接返回false说明线程创建失败： 
25.             1.rs > SHUTDOWN； 此时不再接收新任务，且所有的任务已经执行完毕 
26.             2.rs = SHUTDOWN； 此时不再接收新任务，但是会执行队列中的任务，在后面的或语句中，第一个不成立，firstTask != null成立 
27.             3.rs = SHUTDOWN；此时不再接收新任务，fistTask == null,任务队列workQueue已经空了 
28.  
29.             转换成一个等价实现： 
30.             rs >= SHUTDOWN && (rs != SHUTDOWN || firstTask != null || workQueue.isEmpty())， 
31.  
32.             rs != SHUTDOWN结合前面的rs >= SHUTDOWN，表示线程池的状态已经由SHUTDOWN转为剩余的三个状态之一了，此时就要拒绝这个传入的任务； 
33.             括号里的第二个条件表示状态已经为非运行状态了，却传入了一个任务，这个任务也要拒绝； 
34.             括号里的第三个条件表示线程池的状态不为RUNNING，但队列中没有任务了，就不需要新增线程了。 
35.              */  
36.             if (rs >= SHUTDOWN && //如果已经调用了SHUTDOWN，池的状态改变后，这里就为true  
37.                     ! (rs == SHUTDOWN &&  
38.                             firstTask == null &&  
39.                             ! workQueue.isEmpty()))  
40.                 return false;  
41.   
42.             for (;;) {  
43.                 int wc = workerCountOf(c); // 取出当前活动的线程数。  
44.                 /* 
45.                 若当前活动线程数超过低29位能表示的最大值（也就是容量）时就不能再加线程了，因为再加就会影响状态的值了！ 
46.  
47.                 若传入的参数core参数为true，则当前活动的线程数要小于corePoolSize才能创建新线程，大于或等于corePoolSize就不能再创建了； 
48.                 若core参数为false，则当前活动的线程数要小于maximumPoolSize才能创建新线程，大于或等于maximumPoolSize就不能再创建了。 
49.                  */  
50.                 if (wc >= CAPACITY ||  
51.                         wc >= (core ? corePoolSize : maximumPoolSize))  
52.                     return false;  
53.   
54.                 //比较当前值是否和c相同，如果相同，则改为c+1，并且跳出大循环，直接执行Worker进行线程创建  
55.                 if (compareAndIncrementWorkerCount(c)) // 使用CAS操作将当前活动线程数加一  
56.                     break retry; // 当加一成功，则跳出大循环，进入循环体后面的真正新增线程的地方；  
57.                 c = ctl.get();  // Re-read ctl  
58.   
59.                 //若加一不成功，判断下当前状态改变没有，若改变了则重新开始外层循环的下一次迭代，  
60.                 // 若状态没有改变，只是加一失败，那么就继续内层循环，直到加一成功。  
61.                 /* 
62.                 往当前活动线程数加一成功后，就会来真的新增线程了 
63.                 （先加一后新增线程可以避免锁的使用，使用CAS原子操作加一后，其它线程看到的就是加一后的值， 
64.                 若达到上限，其它线程就不会去创建新线程了。若先创建线程，再去加一，若不加锁， 
65.                 假如一个使用无界队列的线程池，当前活动线程数为corePoolSize少一， 
66.                 外部线程在执行execute的时候都发现线程数不足corePoolSize，都去创建线程， 
67.                 而最终只能有一个线程进入线程池，其它的都得作废，而加锁可以解决这个问题，但是降低了线程池的可伸缩性）。 
68.                  */  
69.                 if (runStateOf(c) != rs)  
70.                     continue retry;  
71.                 // else CAS failed due to workerCount change; retry inner loop  
72.             }  
73.         }  
74.   
75.         //下面这里就是开始创建新的线程了!!!  
76.         //Worker的也是Runnable的实现类  
77.         boolean workerStarted = false;  
78.         boolean workerAdded = false;  
79.         ThreadPoolExecutor.Worker w = null;  
80.         try {  
81.             final ReentrantLock mainLock = this.mainLock;  
82.   
83.             /* 
84.             Worker为内部类，封装了线程和任务，通过ThreadFactory创建线程，可能失败抛异常或者返回null 
85.  
86.             在Worker的构造方法中，创建了一个线程对象，但这个线程是没有启动的。 
87.             在构造方法中启动线程，会导致this对象泄露，让线程看到未完整构建的对象，这个要避免。 
88.              */  
89.             w = new ThreadPoolExecutor.Worker(firstTask);  
90.             //因为不可以直接在Worker的构造方法中进行线程创建,所以要把它的引用赋给t方便后面进行线程创建  
91.             final Thread t = w.thread;  
92.   
93.             //因为上面的两个整个过程并不是互斥的，所以创建完线程对象后再来判断下当前池的状态  
94.             /* 
95.             为啥会出现t==null? Worker的构造方法是通过调用getThreadFactory().newThread(this)方法来创建线程的， 
96.             而newThread方法可能会返回null（threadFactory可以通过ThreadPoolExecutor的构造方法传入，如没有传入，有个默认实现） 
97.              */  
98.             if (t != null) {  
99.                 mainLock.lock();  
100.                 try {  
101.                     //再次取出ctl的当前值，用于进行状态的检查，防止线程池的已经状态改变了  
102.                     int c = ctl.get();  
103.                     int rs = runStateOf(c);  
104.   
105.                     /* 
106.                     当创建线程失败要减少当前活动线程数；当池的状态非RUNNING和SHUTDOWN的时候，也需要减少当前活动线程数，并要尝试终止线程池； 
107.                     当线程池的状态为非RUNNING，且有初始任务要执行的时候，因为这个状态要拒绝新进来的任务，所以这个新增的线程也没有用处了。 
108.                      */  
109.                     if (rs < SHUTDOWN ||  
110.                             (rs == SHUTDOWN && firstTask == null)) {  // 当状态判断没有问题，往下执行  
111.                         if (t.isAlive()) // precheck that t is startable  
112.                             throw new IllegalThreadStateException();  
113.   
114.                         workers.add(w);    //将创建的线程添加到workers容器中（线程终止时会从里面移除）  
115.                         int s = workers.size();   //获取当前线程活动的数量  
116.                         if (s > largestPoolSize)  //判断当前线程活动的数量是否超过线程池最大的线程数量  
117.                             largestPoolSize = s;  //当池中的工作线程创新高时，会将这个数记录到largestPoolSize字段中。然后就可以启动这个线程t了  
118.                         workerAdded = true;  
119.                     }  
120.                 } finally {  
121.                     mainLock.unlock();  
122.                 }  
123.                 if (workerAdded) {  
124.                     t.start();  //开启线程  
125.                     workerStarted = true;  
126.                 }  
127.             }  
128.         } finally {  
129.             if (! workerStarted)  
130.                 addWorkerFailed(w);  // 创建线程失败  
131.         }  
132.         return workerStarted;  
133.     }  
134.   
135.     // 创建线程失败  
136.     private void addWorkerFailed(ThreadPoolExecutor.Worker w) {  
137.         final ReentrantLock mainLock = this.mainLock;  
138.         mainLock.lock();  
139.         try {  
140.             if (w != null)  
141.                 workers.remove(w); // 从workers容器中移除  
142.             decrementWorkerCount();  //减少一个活动的当前线程数  
143.             tryTerminate();  //尝试终止线程池  
144.         } finally {  
145.             mainLock.unlock();  
146.         }  
147.     }  

那么在创建线程的时候，线程执行的是什么的呢？

　　我们前面提到Worker继承的其实也是Runnable，它在创建线程的时候是以自身作为任务传进先创建的线程中的，这段比较简单，我就不一一注释了，只是给出源代码给大家看吧。

在继续其他方法之前，先说下Worker这个内部类。我们看一下每次新增一个线程后这个线程都做了些什么，显然需要看看Worker的run方法：

[java] view plain copy

1.    /** 
2.      * Worker实现了Runnable接口，可以在后续作为Thread的构造方法参数用以创建线程。 
3.      * 同时,Worker还继承了AbstractQueuedSynchronizer类，只是简化每个Worker对象相关的锁的获取，在每次执行一个任务的时候，都需要持有这个锁。 
4.      * 
5.      * 在以前的ThreadPoolExecutor实现中，并没有继承AbstractQueuedSynchronizer， 
6.      * 而是在Worker内部声明了一个对象字段private final ReentrantLock runLock = new ReentrantLock()， 
7.      * 每次执行一个任务的时候，需要对runLock加锁。 
8.      */  
9.     private final class Worker  
10.             extends AbstractQueuedSynchronizer  
11.             implements Runnable {  
12.         ......  
13.         Worker(Runnable firstTask) {  
14.             setState(-1); // inhibit interrupts until runWorker  
15.             this.firstTask = firstTask;  
16.             //this指的是worker对象本身  
17.             this.thread = getThreadFactory().newThread(this);  
18.         }  
19.   
20.         //它以自身的对象作为线程任务传进去，那么它的run方法又是怎样的呢？  
21.         public void run() {  
22.             runWorker(this);  
23.         }  
24.         ......  
25.     }  

只是简单的调用了runWorker方法，继续看runWorker：

    这个方法逻辑很简单。还记得前面提到的新增线程时指定第一个任务吗？若存在第一个任务，则先执行第一个任务，否则，从队列中拿任务，不断的执行，直到getTask返回null或执行任务出错（中断或任务本身抛出异常），就退出while循环。getTask方法后面会详细讲解。当有任务执行时（之前通过参数传入的第一个任务或从队列中获取的任务），需要做一个状态判断。也就是clearInterruptsForTaskRun方法，来看看这个方法干了什么：(这个原来的方法就是下面if里的条件)

[java] view plain copy

1. /** 
2.      * 执行Worker中的任务，它的执行流程是这样的： 
3.      * 若存在第一个任务，则先执行第一个任务，否则，从队列中拿任务，不断的执行， 
4.      * 直到getTask()返回null或执行任务出错（中断或任务本身抛出异常），就退出while循环。 
5.      */  
6.     final void runWorker(ThreadPoolExecutor.Worker w) {  
7.         Thread wt = Thread.currentThread();  
8.         Runnable task = w.firstTask;   //将当前Worker中的任务取出来交给task，并释放掉w.firstTask占用的内存  
9.         w.firstTask = null;  
10.         w.unlock(); // allow interrupts  
11.   
12.         /*用于判断线程是否由于异常终止，如果不是异常终止，在后面将会将该变量的值改为false 
13.         该变量的值在processWorkerExit()会使用来判断线程是否由于异常终止*/  
14.         boolean completedAbruptly = true;  
15.         try {  
16.             //执行任务，直到getTask()返回的值为null，在此处就相当于复用了线程，让线程执行了多个任务  
17.             while (task != null || (task = getTask()) != null) {  
18.                 w.lock();  
19.   
20.                 /* 
21.                 这里利用了&&的短路特性，当前一个条件为true的时候才去执行后面一个条件。 
22.  
23.                 当当前状态小于STOP时，也就是当前状态为RUNNING时，需要清除线程的中断状态 
24.                 （线程池为RUNNING状态，线程却的中断状态却为true， 
25.                 可能在上次执行的任务里调用了类似Thread.currentThread().interrupt()的方法， 
26.                 因此当然不能让接下来执行的任务受之前任务的影响）， 
27.  
28.                 如果Thread.interrupted()返回false，表示以前没有设置过中断，整个if的结果就是false； 
29.  
30.                 如果Thread.interrupted()返回true，那就要考虑为什么会是true了。 
31.                 是RUNNING状态就已经被中断了还是判断第一个条件后另外一个非池中的线程调用了shutdownNow中断了该线程？如 
32.                 果是后者，表示正在执行的任务需要中断，所以第三个条件判断当前池的状态是否不为RUNNING， 
33.  
34.                 如果不为RUNNING，那么就要重新中断该线程以维护shutdownNow方法的语义。 
35.                  */  
36.                 if ((runStateAtLeast(ctl.get(), STOP) ||  
37.                         (Thread.interrupted() &&  
38.                                 runStateAtLeast(ctl.get(), STOP))) &&  
39.                         !wt.isInterrupted())  //这个if条件就是原来的clearInterruptsForTaskRun  
40.                     wt.interrupt();  
41.                 try {  
42.                     //在真正执行任务前，调用该方法。这是一个钩子方法，  
43.                     // 用户可以继承ThreadPoolExecutor重写beforeExecute方法来做一些事情。  
44.                     beforeExecute(wt, task);  
45.                     Throwable thrown = null;  
46.                     try {  
47.                         task.run(); //开始执行任务  
48.                     } catch (RuntimeException x) {  
49.                         thrown = x; throw x;  
50.                     } catch (Error x) {  
51.                         thrown = x; throw x;  
52.                     } catch (Throwable x) {  
53.                         thrown = x; throw new Error(x);  
54.                     } finally {  
55.                         afterExecute(task, thrown); //也是个钩子方法，同beforeExecute方法。  
56.                     }  
57.                 } finally {  
58.                     /* 
59.                     随后将task变量置为null，让其再从队列里接收任务， 
60.                     若不置为null，就满足while的第一个条件了，结果就是这个任务被死循环执行 
61.                      */  
62.                     task = null;  
63.                     w.completedTasks++; // 然后将该线程完成的任务数自增  
64.                     w.unlock();  
65.                     /* 
66.                     只有当线程终止的时候，才会将该线程执行的任务总数加到线程池的completedTaskCount中， 
67.                     所以completedTaskCount这个值并不是一个准确值。 
68.                      */  
69.                 }  
70.             }  
71.             /* 
72.             在最后有一个将completedAbruptly置为false的操作， 
73.             如果线程能走到这里来，说明该线程在执行任务过程中没有抛出异常，也就是说该线程并不是异常结束的，而是正常结束的； 
74.             如果走不到这一步，completedAbruptly的值还是初始值true，表示线程是异常结束的。 
75.              */  
76.             completedAbruptly = false;  
77.         } finally {  
78.             // 线程结束时，会调用processWorkerExit方法做一些清理和数据同步的工作：  
79.             processWorkerExit(w, completedAbruptly);  
80.         }  
81.     }  
82.   
83.     private static boolean runStateAtLeast(int c, int s) {  
84.         return c >= s;  
85.     }  
86.   
87.     protected void beforeExecute(Thread t, Runnable r) { }  
88.   
89.     protected void afterExecute(Runnable r, Throwable t) { }  

线程结束时，会调用processWorkerExit方法做一些清理和数据同步的工作：

[java] view plain copy

1. <pre name="code" class="java">    /** 
2.      * 对线程的结束做一些清理和数据同步 
3.      * @param w 封装线程的Worker 
4.      * @param completedAbruptly 表示该线程是否结束于异常 
5.      */  
6.     private void processWorkerExit(ThreadPoolExecutor.Worker w, boolean completedAbruptly) {  
7.         if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted  
8.             decrementWorkerCount();  //此时将线程数量减一  
9.   
10.         final ReentrantLock mainLock = this.mainLock;  
11.         mainLock.lock();  
12.         try {  
13.             completedTaskCount += w.completedTasks;   //统计总共完成的任务数  
14.             workers.remove(w); //将该线程数从workers容器中移除  
15.         } finally {  
16.             mainLock.unlock();  
17.         }  
18.   
19.         tryTerminate();   //尝试终止线程池  
20.   
21.         int c = ctl.get();  
22.   
23.         /*接下来的这个if块要做的事儿了。当池的状态还是RUNNING， 
24.         又要分两种情况，一种是异常结束，一种是正常结束。异常结束比较好弄，直接加个线程替换死掉的线程就好了, 
25.         也就是最后的addWorker操作  */  
26.         if (runStateLessThan(c, STOP)) {  //如果当前运行状态为RUNNING，SHUTDOWN  
27.             if (!completedAbruptly) {  //如果线程不是结束于异常  
28.                 int min = allowCoreThreadTimeOut ? 0 : corePoolSize; //是否允许线程超时结束  
29.                 if (min == 0 && ! workQueue.isEmpty())  //如果允许把那个且队列不为空  
30.                     min = 1;  //至少要保留一个线程来完成任务  
31.   
32.                 //如果当前活动的线程数大于等于最小的值  
33.                 // 1.不允许核心线程超时结束，则必须要使得活动线程数超过corePoolSize数才可以  
34.                 // 2. 允许核心线程超时结束，但是队列中有任务，必须留至少一个线程  
35.                 if (workerCountOf(c) >= min)  
36.                     return; // replacement not needed  
37.             }  
38.             //直接加个线程  
39.             addWorker(null, false);  
40.         }  
41.     }  
42.   
43.     private void decrementWorkerCount() {  
44.         do {} while (! compareAndDecrementWorkerCount(ctl.get()));  
45.     }  
46.     private boolean compareAndDecrementWorkerCount(int expect) {  
47.         return ctl.compareAndSet(expect, expect - 1);  
48.     }  
49.   
50.     private static boolean runStateLessThan(int c, int s) {  
51.         return c < s;  
52.     }  

    如果线程是异常结束（被中断、任务执行本身异常等），当前活动的线程数减少一个。如果是正常结束的呢？不应该将其也减一吗？不用担心，在runWorker的while最后一次循环中的getTask方法里做掉了。    接下来将该线程执行过的任务数加到completedTaskCount中，这个在前面也提到了。然后从workers中去除该工作线程。如果该线程的中断是因为调用了shutdown、shutdownNow接口而中断的该如何处理？就是这个tryTerminate了，来看下tryTerminate干了什么：

[java] view plain copy

1. <pre name="code" class="java">    /** 
2.      * 执行该方法，根据线程池状态进行  判断是否结束线程池 
3.      */  
4.     final void tryTerminate() {  
5.         for (;;) {  
6.             int c = ctl.get();  
7.   
8.             /* 
9.             当池的状态为SHUTDOWN且任务队列为空，需要将池的状态转变为TERMINATED； 
10.             当池的状态为STOP且池中的当前活动线程数为0，要将池的状态转换成TERMINATED。这个方法就是用来做这种状态转变的。 
11.             如果状态是RUNNING，表示线程池还正在提供服务，不需要状态变换； 
12.             如果状态为TIDYING或TERMINATED，池中的活动线程数已经是0，自然也不需要做什么操作了； 
13.             若状态为SHUTDWON，但队列中还有任务，此时这些任务还需要做掉，因此池中的线程不能终止，因此，这种情况下也不需要做什么。 
14.              */  
15.             if (isRunning(c) ||    //线程池正在运行中，自然不能结束线程池啦  
16.                     runStateAtLeast(c, TIDYING) ||    //如果状态为TIDYING或TERMINATED，池中的活动线程数已经是0，自然也不需要做什么操作了  
17.                     (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))    //线程池出于SHUTDOWN状态，但是任务队列不为空，自然不能结束线程池啦  
18.                 return;  
19.   
20.             //如果状态为SHUTDWON但队列中已经没有任务了，这里调用了一个interruptIdleWorkers(ONLY_ONE)操作去中断一个空闲线程。  
21.             if (workerCountOf(c) != 0) { // Eligible to terminate  
22.                 /* 
23.                   调用这个方法的目的是将shutdown信号传播给其它线程。 
24.                   调用shutdown方法的时候会去中断所有空闲线程，如果这时候池中所有的线程都正在执行任务， 
25.                   那么就不会有线程被中断，调用shutdown方法只是设置了线程池的状态为SHUTDOWN， 
26.                   在取任务(getTask,后面会细说)的时候，假如很多线程都发现队列里还有任务（没有使用锁，存在竞态条件）， 
27.                   然后都去调用take，如果任务数小于池中的线程数，那么必然有方法调用take后会一直等待（shutdown的时候这些线程正在执行任务， 
28.                   所以没能调用它的interrupt，其中断状态没有被设置），那么在没有任务且线程池的状态为SHUTDWON的时候， 
29.                   这些等待中的空闲线程就需要被终止iinterruptIdleWorkers(ONLY_ONE)回去中断一个线程，让其从take中退出， 
30.                   然后这个线程也进入同样的逻辑，去终止一个其它空闲线程，直到池中的活动线程数为0。 
31.                 */  
32.                 interruptIdleWorkers(ONLY_ONE);  
33.                 return;  
34.             }  
35.   
36.             final ReentrantLock mainLock = this.mainLock;  
37.             mainLock.lock();  
38.             try {  
39.                 /* 
40.                   当状态为SHUTDOWN，且活动线程数为0的时候，就可以进入TIDYING状态了， 
41.                   进入TIDYING状态就可以执行钩子方法terminated()， 
42.                   该方法执行结束就进入了TERMINATED状态（参考前文中各状态的含义以及可能的状态转变） 
43.                 */  
44.                 if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {  
45.                     try {  
46.                         terminated();    //执行该方法，结束线程池  
47.                     } finally {  
48.                         ctl.set(ctlOf(TERMINATED, 0));  
49.                         /* 
50.                           当线程池shutdown后，外部可能还有很多线程在等待线程池真正结束， 
51.                           即调用了awaitTermination方法，该方法中，外部线程就是在termination上await的， 
52.                           所以，线程池关闭之前要唤醒这些等待的线程，告诉它们线程池关闭结束了。 
53.                         */  
54.                         termination.signalAll();  
55.                     }  
56.                     return;  
57.                 }  
58.             } finally {  
59.                 mainLock.unlock();  
60.             }  
61.             // else retry on failed CAS  
62.         }  
63.     }  
64.   
65.     private static boolean runStateAtLeast(int c, int s) {  
66.         return c >= s;  
67.     }  

继续说processWorkerExit方法中调用tryTerminate之后的代码。如果池的状态仍为RUNNING，而线程是因为执行的任务本身抛出了异常而结束或正常结束时该如何处理？这时候池的状态还是RUNNING呢！那就是接下来的这个if块要做的事儿了。当池的状态还是RUNNING，又要分两种情况，一种是异常结束，一种是正常结束。异常结束比较好弄，直接加个线程替换死掉的线程就好了，也就是最后的addWorker操作。而正常结束又有几种情况了，如果允许core线程超时，也就是allowCoreThreadTimeOut为true，那么在池中没有任务的时候，调用带有时限参数的poll方法时就可能返回null，致使线程正常退出，如果允许core线程超时，池中最小的线程数可为0，如果此时队列又有任务了，那么池中必须要有一个线程，若池中活动的线程数不为0，就不需要新增线程来替换死掉的线程，否则就要新增一个；如果不允许core线程超时，池中的线程必须达到corePoolSize个才能让多的线程退出，而不需要用新的线程替换，否则也需要新增一个线程替换这个死掉的线程。

在runWorker执行任务之前调用了w.lock操作，为什么要在执行任务的时候锁定这个每个线程都有一份的锁呢？原因在于调用了线程池shutdown后（前面说过，SHUTDOWN的含义：不再接受新任务，但仍可以执行队列中的任务），会调用interruptIdleWorkers方法去终止空闲线程，该方法会持有mainLock锁，但此时队列中可能还有很多任务，线程也可能还正在执行任务，就可能有一些线程终止不掉。此时，有些线程可能刚执行任务结束，正准备再去队列中拿任务，有些可能还正在执行任务，有些可能刚拿到一个新的任务，对于仍进入队列中拿任务的线程，最终队列中任务会被拿完，而此时拿任务的线程会发现线程池的状态为SHUTDOWN，就会立马返回一个null，返回null意味着ThreadPoolExecutor.runWorker中的循环退出了，这个线程也就自动终止了；此外拿任务并没有持有mainLock锁，所以在终止空闲线程与线程非执行任务期间（如从队列获取任务）存在竞态条件。有可能已经判断了线程池的状态仍未RUNNING，准备从queue里take任务，而在执行take之前，另一个非池中的线程可能调用了shutdown，并且执行完了interruptIdleWorkers方法（马上就会介绍这个方法），若此时队列中恰好没有任务了，若这个正要调用take的线程阻塞，就不会醒过来了，不用担心，interruptIdleWorkers已经中断了该线程，而take是可以响应中断的，再调用take后会立马抛出异常。 对于正在执行中的任务，其它线程不能直接将这个正在线程中断掉，因此除了mainLock锁，interruptIdleWorkers还需要持有线程执行任务时获取的那把锁（这也是为什么执行任务的时候需要获取那个每个线程都有的锁的原因），如果获取不成功表示线程正在执行任务。

-----------------------------------------------------------------------------------------

2、关闭线程池

看下终止空闲线程的方法实现：

[java] view plain copy

1. private void interruptIdleWorkers() {  
2.     interruptIdleWorkers(false);  
3. }  
4.   
5. private void interruptIdleWorkers(boolean onlyOne) {  
6.     final ReentrantLock mainLock = this.mainLock;  
7.     mainLock.lock();  
8.     try {  
9.         for (ThreadPoolExecutor.Worker w : workers) {  
10.             Thread t = w.thread;  
11.             if (!t.isInterrupted() && w.tryLock()) {  
12.                 try {  
13.                     t.interrupt();  
14.                 } catch (SecurityException ignore) {  
15.                 } finally {  
16.                     w.unlock();  
17.                 }  
18.             }  
19.             if (onlyOne)  
20.                 break;  
21.         }  
22.     } finally {  
23.         mainLock.unlock();  
24.     }  
25. }  
26. private void interruptWorkers() {  
27.     final ReentrantLock mainLock = this.mainLock;  
28.     mainLock.lock();  
29.     try {  
30.         for (ThreadPoolExecutor.Worker w : workers)  
31.             w.interruptIfStarted();  
32.     } finally {  
33.         mainLock.unlock();  
34.     }  
35. }  

interruptIdleWorkers遍历workers中所有的工作线程，若线程没有被中断且能立即（tryLock）获取到前面提到的那把线程任务锁时，就中断该线程。为什么需要持有mainLock？mainLock是用来保护workers变量的。

shutdown是持有mainLock的，但是runWorker的时候并没有，那么，会不会出现碰巧出现同一时刻池中所有线程都刚好执行完任务，去取任务的时候发现池的状态为SHUTDOWN，就立即返回null并终止线程，而导致队列中的剩下的任务得不到执行？这是不会出现的，来看下getTask的实现：

[java] view plain copy

1. private Runnable getTask() {  
2.     boolean timedOut = false; // Did the last poll() time out?  
3.   
4.     retry:  
5.     for (;;) {  
6.         int c = ctl.get();  
7.         int rs = runStateOf(c);  
8.   
9.         // Check if queue empty only if necessary.  
10.         if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {  
11.             decrementWorkerCount();  
12.             return null;  
13.         }  
14.   
15.         boolean timed;      // Are workers subject to culling?  
16.   
17.         for (;;) {  
18.             int wc = workerCountOf(c);  
19.             timed = allowCoreThreadTimeOut || wc > corePoolSize;  
20.   
21.             if (wc <= maximumPoolSize && ! (timedOut && timed))  
22.                 break;  
23.             if (compareAndDecrementWorkerCount(c))  
24.                 return null;  
25.             c = ctl.get();  // Re-read ctl  
26.             if (runStateOf(c) != rs)  
27.                 continue retry;  
28.             // else CAS failed due to workerCount change; retry inner loop  
29.         }  
30.   
31.         try {  
32.             Runnable r = timed ?  
33.                 workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :  
34.                 workQueue.take();  
35.             if (r != null)  
36.                 return r;  
37.             timedOut = true;  
38.         } catch (InterruptedException retry) {  
39.             timedOut = false;  
40.         }  
41.     }  
42. }  

若进入这个方法的工作线程是即将要终止的线程，该方法就必须返回null，有以下几种情形需要返回null：
1、当前活动线程数超过maximumPoolSize个（调用了setMaximumPoolSize的缘故）；
2、线程池已经停止（STOP）；
3、线程池已经关闭（SHUTDOWN）且任务队列为空；
4、工作线程获取任务超时，且满足(allowCoreThreadTimeOut || workerCount > corePoolSize)条件

先获取线程池的状态，如果状态大于等于STOP，也就是STOP、TIDYING、TERMINATED之一，这时候不管队列中有没有任务，都不用去执行了；如果线程池的状态为SHUTDOWN且队列中没有任务了，也不用继续执行了；所以这两种场景中获取任务的线程没必要存在了，这里调用了decrementWorkerCount减少活动线程数。前面在processWorkerExit中也提到，如果任务是非正常终止，processWorkerExit里要将活动线程数减一，正常的线程退出，减一是在这里做的。返回null之后，runWorker的while循环就退出了。接下来是个嵌套循环，它的目的就是上述的1和4.后面是从队列中取任务，比较简单，不多说。

[java] view plain copy

1. // 确保允许调用发interrupt每个Worker线程的  
2. private void checkShutdownAccess() {  
3.     SecurityManager security = System.getSecurityManager();  
4.     if (security != null) {  
5.         // 检查权限（以抛出异常的形式）  
6.         security.checkPermission(shutdownPerm);  
7.         final ReentrantLock mainLock = this.mainLock;  
8.         mainLock.lock();  
9.         try {  
10.             for (ThreadPoolExecutor.Worker w : workers)  
11.                 security.checkAccess(w.thread);  
12.         } finally {  
13.             mainLock.unlock();  
14.         }  
15.     }  
16. }  
17.   
18. /** 
19.  * 按过去执行已提交任务的顺序发起一个有序的关闭，但是不接受新任务。 
20.  * 如果线程池已经关闭，则调用没有其他作用。 
21.  * 该方法不会等待之前已经提交的任务执行完毕，awaitTermination方法才有这个效果。 
22.  * 
23.  * 抛出：SecurityException 
24.  *      - 如果安全管理器存在并且关闭此 ExecutorService 
25.  *      可能操作某些不允许调用者修改的线程（因为它没有 RuntimePermission("modifyThread")）， 
26.  *      或者安全管理器的 checkAccess 方法拒绝访问。 
27.  */  
28. public void shutdown() {  
29.     final ReentrantLock mainLock = this.mainLock;  
30.     mainLock.lock();  
31.     try {  
32.         checkShutdownAccess();    // 检查终止线程池的线程是否有权限。  
33.         advanceRunState(SHUTDOWN);// 设置线程池的状态为关闭状态。  
34.         interruptIdleWorkers();   // 中断线程池中空闲的线程  
35.         onShutdown();             // 钩子函数，在ThreadPoolExecutor中没有任何动作  
36.     } finally {  
37.         mainLock.unlock();  
38.     }  
39.     tryTerminate();               // 尝试终止线程池  
40. }  
41.   
42.   
43. /** 
44.  * 尝试停止所有的活动执行任务、暂停等待任务的处理，并返回等待执行的任务列表。 
45.  * 在从此方法返回的任务队列中排空（移除）这些任务。 
46.  * 并不保证能够停止正在处理的活动执行任务，但是会尽力尝试。 
47.  * 此实现通过 Thread.interrupt() 取消任务，所以无法响应中断的任何任务可能永远无法终止。 
48.  * 
49.  * 返回：从未开始执行的任务的列表。 
50.  * 抛出：SecurityException - 如果安全管理器存在并且关闭此 ExecutorService 
51.  *       可能操作某些不允许调用者修改的线程（因为它没有 RuntimePermission("modifyThread")）， 
52.  *        或者安全管理器的 checkAccess 方法拒绝访问。 
53.  */  
54. public List<Runnable> shutdownNow() {  
55.     List<Runnable> tasks;  
56.     final ReentrantLock mainLock = this.mainLock;  
57.     mainLock.lock();  
58.     try {  
59.         checkShutdownAccess();  
60.         advanceRunState(STOP);  
61.         interruptWorkers();  
62.         tasks = drainQueue();  
63.     } finally {  
64.         mainLock.unlock();  
65.     }  
66.     tryTerminate();  
67.     return tasks;  
68. }  
69.   
70.   
71.   
72.   
73. /** 
74.  * 中断所有线程，即使线程还是active的。忽略所有SecurityExceptions异常。 
75.  */  
76. private void interruptWorkers() {  
77.     final ReentrantLock mainLock = this.mainLock;  
78.     mainLock.lock();  
79.     try {  
80.         for (ThreadPoolExecutor.Worker w : workers)  
81.             w.interruptIfStarted();  
82.     } finally {  
83.         mainLock.unlock();  
84.     }  
85. }  
86.   
87. /** 
88.  * 中断那些可能在等待执行任务的线程，让他们能检查是否可以terminate。 
89.  * 这里直接吞了SecurityException异常，防止某些线程在interrupt之后仍然处于uninterrupted状态。 
90.  * 
91.  * @param onlyOne 如果是true，最多只中断一个Worker。 
92.  * 这种情况只有在tryTerminate调用的时候才会出现，表示可以termination，但是还有其他的Worker存在。 
93.  * 在这种情况下，最多只有一个处于等待的Worker被中断，来保证shutdown信号的繁衍传递(propagate语义)， 
94.  * 以便能处理所有信号都处于等待状态的情况， 
95.  *     中断任意一个随机的线程都能保证从shutdown操作开始之后新添加的Worker最终都能退出。 
96.  * 为了保证最终的termination，永远只interrupt一个线程就足够了(为什么足够)， 
97.  * 但是shutdown操作总是所有idle的workers，这样冗余的workers可以立即退出, 
98.  * 而不是等待一个straggler任务来完成操作。 
99.  */  
100. private void interruptIdleWorkers(boolean onlyOne) {  
101.     final ReentrantLock mainLock = this.mainLock;  
102.     mainLock.lock();  
103.     try {  
104.         for (ThreadPoolExecutor.Worker w : workers) {  
105.             Thread t = w.thread;  
106.             if (!t.isInterrupted() && w.tryLock()) {  
107.                 try {  
108.                     t.interrupt();  
109.                 } catch (SecurityException ignore) {  
110.                 } finally {  
111.                     w.unlock();  
112.                 }  
113.             }  
114.             if (onlyOne)  
115.                 break;  
116.         }  
117.     } finally {  
118.         mainLock.unlock();  
119.     }  
120. }  
121.   
122. /** 
123.  * Common form of interruptIdleWorkers, to avoid having to 
124.  * remember what the boolean argument means. 
125.  */  
126. private void interruptIdleWorkers() {  
127.     interruptIdleWorkers(false);  
128. }  

以上，核心方法分析结束。欢迎指出理解错漏的地方。

转自：http://blog.csdn.net/ochangwen/article/details/53045979