ExecutorService接口继承了Executor接口，定义了一些生命周期的方法

Java代码  

1. public interface ExecutorService extends Executor {  
2. void shutdown();  
3. List<Runnable> shutdownNow();  
4. boolean isShutdown();  
5. boolean isTerminated();  
6. boolean awaitTermination(long timeout, TimeUnit unit)  
7.         throws InterruptedException;  
8. }  

本文，我们逐一分析里面的每个方法。

首先，我们需要创建一个任务代码，这段任务代码主要是随机生成含有10个字符的字符串

Java代码  

1. /** 
2.  * 随机生成10个字符的字符串 
3.  * @author dream-victor 
4.  * 
5.  */  
6. public class Task1 implements Callable<String> {  
7.   
8.     @Override  
9.     public String call() throws Exception {  
10.         String base = “abcdefghijklmnopqrstuvwxyz0123456789”;  
11.         Random random = new Random();  
12.         StringBuffer sb = new StringBuffer();  
13.         for (int i = 0; i < 10; i++) {  
14.             int number = random.nextInt(base.length());  
15.             sb.append(base.charAt(number));  
16.         }  
17.         return sb.toString();  
18.     }  
19.   
20. }  

 然后，我们还需要一个长任务，这里我们默认是沉睡10秒，

Java代码  

1. /** 
2.  * 长时间任务 
3.  *  
4.  * @author dream-victor 
5.  *  
6.  */  
7. public class LongTask implements Callable<String> {  
8.   
9.     @Override  
10.     public String call() throws Exception {  
11.         TimeUnit.SECONDS.sleep(10);  
12.         return “success”;  
13.     }  
14.   
15. }  

OK，所有前期准备完毕，下面我们就来分析一下ExecutorService接口中和生命周期有关的这些方法：

1、shutdown方法：这个方法会平滑地关闭ExecutorService，当我们调用这个方法时，ExecutorService停止接受任何新的任务且等待已经提交的任务执行完成(已经提交的任务会分两类：一类是已经在执行的，另一类是还没有开始执行的)，当所有已经提交的任务执行完毕后将会关闭ExecutorService。这里我们先不举例在下面举例。

2、awaitTermination方法：这个方法有两个参数，一个是timeout即超时时间，另一个是unit即时间单位。这个方法会使线程等待timeout时长，当超过timeout时间后，会监测ExecutorService是否已经关闭，若关闭则返回true，否则返回false。一般情况下会和shutdown方法组合使用。例如：

 这段代码中，我们在第三次提交了一个长任务，这个任务将执行10秒沉睡，紧跟着执行了一次shutdown()方法，假设：这时ExecutorService被立即关闭，下面调用service.awaitTermination(1, TimeUnit.SECONDS)方法时应该返回true，程序执行结果应该只会打印出：“线程池已经关闭”。但是，真实的运行结果如下：

 这说明我们假设错误，service.awaitTermination(1, TimeUnit.SECONDS)每隔一秒监测一次ExecutorService的关闭情况，而长任务正好需要执行10秒，因此会在前9秒监测时ExecutorService为未关闭状态，而在第10秒时已经关闭，因此第10秒时输出：线程池已经关闭。这也验证了shutdown方法关闭ExecutorService的条件。

3、shutdownNow方法：这个方法会强制关闭ExecutorService，它将取消所有运行中的任务和在工作队列中等待的任务，这个方法返回一个List列表，列表中返回的是等待在工作队列中的任务。例如：

 这段代码中，我们限制了线程池的长度是3，提交了5个任务，这样将有两个任务在工作队列中等待，当我们执行shutdownNow方法时，ExecutorService被立刻关闭，所以在service.awaitTermination(1, TimeUnit.MILLISECONDS)方法校验时返回的是false，因此没有输出：线程池没有关闭。而在调用shutdownNow方法时，我们接受到了一个List，这里包含的是在工作队列中等待执行的任务，由于线程池长度为3，且执行的都是长任务，所以当提交了三个任务后线程池已经满了，剩下的两次提交只能在工作队列中等待，因此我们看到runnables的大小为2，结果如下：

4、isTerminated方法：这个方法会校验ExecutorService当前的状态是否为“TERMINATED”即关闭状态，当为“TERMINATED”时返回true否则返回false。例如：

这段代码我们执行了两个正常的任务和一个长任务，然后调用了shutdown方法，我们知道调用shutdown方法并不会立即关闭ExecutorService，这时我们记录一下监测循环执行前的时间，在没有关闭前我们一直进入一个空循环中，直到 ExecutorService关闭后退出循环，这里我们知道长任务执行时间大约为10秒，我们看一下上述程序运行结果：

这10秒正好是长任务执行的时间，因此在 ExecutorService正常关闭后isTerminated方法返回true。

5、isShutdown方法：这个方法在ExecutorService关闭后返回true，否则返回false。方法比较简单不再举例。

以上讨论是基于ThreadPoolExecutor的实现，不同的实现会有所不同需注意。

————————————————————————————————————————————————————————————————————————————————

ExecutorService与Executors例子的简单剖析

 对于多线程有了一点了解之后，那么来看看java.lang.concurrent包下面的一些东西。在此之前，我们运行一个线程都是显式调用了Thread的start()方法。我们用concurrent下面的类来实现一下线程的运行，而且这将成为以后常用的方法或者实现思路。 

        看一个简单的例子： 

Java代码  

1. public class CacheThreadPool {  
2.     public static void main(String[] args) {  
3.         ExecutorService exec=Executors.newCachedThreadPool();  
4.         for(int i=0;i<5;i++)  
5.             exec.execute(new LiftOff());  
6.         exec.shutdown();//并不是终止线程的运行，而是禁止在这个Executor中添加新的任务  
7.     }  
8. }  

        这个例子其实很容易看懂，ExecutorService中有一个execute方法，这个方法的参数是Runnable类型。也就是说，将一个实现了Runnable类型的类的实例作为参数传入execute方法并执行，那么线程就相应的执行了。 

        一、ExecutorService 
        先看看ExecutorService，这是一个接口，简单的列一下这个接口： 

Java代码  

1. public interface ExecutorService extends Executor {  
2.   
3.     void shutdown();  
4.   
5.     List<Runnable> shutdownNow();  
6.   
7.     boolean isShutdown();  
8.   
9.     boolean isTerminated();  
10.   
11.     boolean awaitTermination(long timeout, TimeUnit unit)  
12.   
13.     <T> Future<T> submit(Callable<T> task);  
14.   
15.     <T> Future<T> submit(Runnable task, T result);  
16.   
17.     Future<?> submit(Runnable task);  
18.   
19.     <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)  
20.   
21.     <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)  
22.   
23.     <T> T invokeAny(Collection<? extends Callable<T>> tasks)  
24.   
25.     <T> T invokeAny(Collection<? extends Callable<T>> tasks,  
26.                     long timeout, TimeUnit unit)  
27. }  

        ExecuteService继承了Executor，Executor也是一个接口，里面只有一个方法： 

Java代码  

1. void execute(Runnable command)  

        二、Executors 
        Executors是一个类，直接援引JDK文档的说明来说一下这个类的作用： 
       

• •         Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory, and Callable classes defined in this package. This class supports the following kinds of methods: 

•        
• Methods that create and return an ExecutorService set up with commonly useful configuration settings.       
• Methods that create and return a ScheduledExecutorService set up with commonly useful configuration settings.       
• Methods that create and return a “wrapped” ExecutorService, that disables reconfiguration by making implementation-specific methods inaccessible.       
• Methods that create and return a ThreadFactory that sets newly created threads to a known state.       
• Methods that create and return a Callable out of other closure-like forms, so they can be used in execution methods requiring Callable.       

        在上面的例子中，我们用到了newCachedThreadPool()方法。看一下这个方法： 

Java代码  

1. public static ExecutorService newCachedThreadPool() {  
2.         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,  
3.                                       60L, TimeUnit.SECONDS,  
4.                                       new SynchronousQueue<Runnable>());  
5.     }  

        在源码中我们可以知道两点，1、这个方法返回类型是ExecutorService；2、此方法返回值实际是另一个类的实例。看一下这个类的信息： 

Java代码  

1. public class ThreadPoolExecutor extends AbstractExecutorService {  
2.     ……….  
3.     private final BlockingQueue<Runnable> workQueue;//这个变量在下面会提到  
4.     ……….  
5. }  

        ThreadPoolExecutor继承了AbstractExecutorService,而AbstractExecutorService又实现了ExecutorService接口。所以，根据多态，ThreadPoolExecutor可以看作是ExecutorService类型。 

        线程执行的最关键的一步是执行了executor方法，根据java的动态绑定，实际执行的是ThreadPoolExecutor所实现的executor方法。看看源码： 

Java代码  

1. public class ThreadPoolExecutor extends AbstractExecutorService {  
2.     ……….  
3.     public void execute(Runnable command) {  
4.         if (command == null)  
5.             throw new NullPointerException();  
6.         if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {  
7.             if (runState == RUNNING && workQueue.offer(command)) {  
8.                 if (runState != RUNNING || poolSize == 0)  
9.                     ensureQueuedTaskHandled(command);  
10.             }  
11.             else if (!addIfUnderMaximumPoolSize(command))  
12.                 reject(command); // is shutdown or saturated  
13.         }  
14.     }  
15.     ……….  
16. }  

        根据程序正常执行的路线来看，这个方法中比较重要的两个地方分别是： 
        1、workQueue.offer(command) 
        workQueue在上面提到过，是BlockingQueue<Runnable>类型的变量，这条语句就是将Runnable类型的实例加入到队列中。 
        2、ensureQueuedTaskHandled(command) 
        这个是线程执行的关键语句。看看它的源码： 

Java代码  

1. public class ThreadPoolExecutor extends AbstractExecutorService {  
2.     ……….  
3.     private void ensureQueuedTaskHandled(Runnable command) {  
4.         final ReentrantLock mainLock = this.mainLock;  
5.         mainLock.lock();  
6.         boolean reject = false;  
7.         Thread t = null;  
8.         try {  
9.             int state = runState;  
10.             if (state != RUNNING && workQueue.remove(command))  
11.                 reject = true;  
12.             else if (state < STOP &&  
13.                      poolSize < Math.max(corePoolSize, 1) &&  
14.                      !workQueue.isEmpty())  
15.                 t = addThread(null);  
16.         } finally {  
17.             mainLock.unlock();  
18.         }  
19.         if (reject)  
20.             reject(command);  
21.         else if (t != null)  
22.             t.start();  
23.     }  
24.     ……….  
25. }  

        在这里我们就可以看到最终执行了t.start()方法来运行线程。在这之前的重点是t=addThread(null)方法，看看addThread方法的源码： 

Java代码  

1. public class ThreadPoolExecutor extends AbstractExecutorService {  
2.     ……….  
3.     private Thread addThread(Runnable firstTask) {  
4.         Worker w = new Worker(firstTask);  
5.         Thread t = threadFactory.newThread(w);  
6.         if (t != null) {  
7.             w.thread = t;  
8.             workers.add(w);  
9.             int nt = ++poolSize;  
10.             if (nt > largestPoolSize)  
11.                 largestPoolSize = nt;  
12.         }  
13.         return t;  
14.     }  
15.     ……….  
16. }  

        这里两个重点，很明显： 
        1、Worker w = new Worker(firstTask) 
        2、Thread t = threadFactory.newThread(w) 
        先看Worker是个什么结构： 

Java代码  

1. public class ThreadPoolExecutor extends AbstractExecutorService {  
2.     ……….  
3.     private final class Worker implements Runnable {  
4.         ……….  
5.         Worker(Runnable firstTask) {  
6.             this.firstTask = firstTask;  
7.         }  
8.   
9.         private Runnable firstTask;  
10.         ……….  
11.   
12.         public void run() {  
13.             try {  
14.                 Runnable task = firstTask;  
15.                 firstTask = null;  
16.                 while (task != null || (task = getTask()) != null) {  
17.                     runTask(task);  
18.                     task = null;  
19.                 }  
20.             } finally {  
21.                 workerDone(this);  
22.             }  
23.         }  
24.     }  
25.   
26.     Runnable getTask() {  
27.         for (;;) {  
28.             try {  
29.                 int state = runState;  
30.                 if (state > SHUTDOWN)  
31.                     return null;  
32.                 Runnable r;  
33.                 if (state == SHUTDOWN)  // Help drain queue  
34.                     r = workQueue.poll();  
35.                 else if (poolSize > corePoolSize || allowCoreThreadTimeOut)  
36.                     r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);  
37.                 else  
38.                     r = workQueue.take();  
39.                 if (r != null)  
40.                     return r;  
41.                 if (workerCanExit()) {  
42.                     if (runState >= SHUTDOWN) // Wake up others  
43.                         interruptIdleWorkers();  
44.                     return null;  
45.                 }  
46.                 // Else retry  
47.             } catch (InterruptedException ie) {  
48.                 // On interruption, re-check runState  
49.             }  
50.         }  
51.     }  
52.     }  
53.     ……….  
54. }  

        Worker是一个内部类。根据之前可以知道，传入addThread的参数是null，也就是说Work中firstTask为null。
        在看看newThread是一个什么方法： 

Java代码  

1. public class Executors {  
2.     ……….  
3.     static class DefaultThreadFactory implements ThreadFactory {  
4.         ……….  
5.         public Thread newThread(Runnable r) {  
6.             Thread t = new Thread(group, r,  
7.                                   namePrefix + threadNumber.getAndIncrement(),  
8.                                   0);  
9.             if (t.isDaemon())  
10.                 t.setDaemon(false);  
11.             if (t.getPriority() != Thread.NORM_PRIORITY)  
12.                 t.setPriority(Thread.NORM_PRIORITY);  
13.             return t;  
14.         }  
15.         ……….  
16.     }  
17.     ……….  
18. }  

        通过源码可以得知threadFactory的实际类型是DefaultThreadFactory，而DefaultThreadFactory是Executors的一个嵌套内部类。 

        之前我们提到了t.start()这个方法执行了线程。那么现在从头顺一下，看看到底是执行了谁的run方法。首先知道，t=addThread(null)，而addThread内部执行了下面三步，Worker w = new Worker(null);Thread t = threadFactory.newThread(w);return t;这里两个t是一致的。 
        从这里可以看出，t.start()实际上执行的是Worker内部的run方法。run()内部会在if条件里面使用“短路”：判断firstTask是否为null，若不是null则直接执行firstTask的run方法；如果是null，则调用getTask()方法来获取Runnable类型实例。从哪里获取呢？workQueue！在execute方法中，执行ensureQueuedTaskHandled(command)之前就已经把Runnable类型实例放入到workQueue中了，所以这里可以从workQueue中获取到。