线程执行器和不使用线程执行器的对比（优缺点）

1.线程执行器分离了任务的创建和执行，通过使用执行器，只需要实现Runnable接口的对象，然后把这些对象发送给执行器即可。

2.使用线程池来提高程序的性能。当发送一个任务给执行器时，执行器会尝试使用线程池中的线程来执行这个任务。避免了不断创建和销毁线程导致的性能开销。

3.执行器可以处理实现了Callable接口的任务。Callable接口类似于Runnable接口，却提供了两方面的增强：

a.Callable主方法名称为call(),可以返回结果

b.当发送一个Callable对象给执行器时，将获得一个实现了Future接口的对象。可以使用这个对象来控制Callable对象的状态和结果。

4.提供了一些操作线程任务的功能
使用线程执行器的例子
**

A）执行继承了Runnable接口的任务类

**

package com.springboot.hello.thread;

public class TaskRunnable implements  Runnable{
    private  String name  ;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public TaskRunnable(String name ){
        this.name =name ;
    }

    @Override
    public  void run(){
        try {
            System.out.println(name+ " 任务执行中。。。");
            Thread.sleep(15000);
            System.out.println(name+ " 任务真的执行完了。。。");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    public static void main(String[] args) {
        ExecutorServer  executorServer = new ExecutorServer();
        for (int i = 0; i < 20; i++) {
            TaskRunnable task = new TaskRunnable(" name-"+i);
            executorServer.executorTask(task);//异步处理
        }
        System.out.println("main 方法走完了。。。");
        executorServer.endExecutor();//直到所有进行中的任务执行完毕后才真的关闭主线程了
        System.out.println("main 方法走完了。。endExecutor");

    }
}


使用执行器调用任务类：

```bash
package com.springboot.hello.thread;

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 线程执行器调用任务类
 */
public class ExecutorServer {
    private ThreadPoolExecutor executor  ;
    public  ExecutorServer(){
        executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
    }

    public  void  executorTask(TaskRunnable task){
        System.out.println("===开始执行线程："+ task.getName() );
        executor.submit(task);
        System.out.println("===线程"+task.getName()+"执行完成："+executor.getActiveCount());
    }

    public  void  endExecutor (){
        executor.shutdown();
    }
}

需要注意的地方：
1、ThreadPoolExecutor提供了好几种构造函数，由于这些构造函数的参数比较多，难于记忆，所以这里使用Executors类对其构造函数进行了封装，封装后的静 态函数可以通过函数名称更加直观的表述其含义。
2、执行实现Runnable接口的任务类使用的方式是：executor.execute(task);后面可以看到它和调用实现Callable接口的任务类还是有区别的。
3、使用执行器时要显示结束执行器。如果不关闭，那么执行器会一直执行而程序不会结束。如果执行器没有任务执行了，它将继续等待新任务的到来，而不会 结束执行。结束执行器这里使用的方式是shutdown();

**

B) 执行实现了Callable接口的任务

**

package com.springboot.hello.thread;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.*;

public class TaskCallable implements Callable<String> {

    private  String name ;

    public   TaskCallable(String name){
        this.name = name ;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String call() throws Exception {
        return  dealData(name);
    }

    public  String dealData(String name){
        System.out.println(name+" dealData处理开始");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name+" dealData处理完成");
        return  name +" success" ;
    }

    public static void main(String[] args) {
        Long startTime = System.currentTimeMillis() ;
        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(2);
        for (int i = 0; i < 20; i++) {
            System.out.println("开始循环处理name"+i);
            TaskCallable taskCallable = new TaskCallable("name"+i);
            Future<String > futureResult =  executor.submit(taskCallable) ;//（同步处理）会等待当前线程的执行结果，获取结果后才往下走

            try {
                if (i ==9 ){
                    futureResult.cancel(true);
                    //System.out.println("task name"+i+" 取消成功结果："+futureResult.get());
                }else {
                    System.out.println("task name"+i+" 执行结果："+futureResult.get());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        System.out.println("耗时==="+( System.currentTimeMillis()-startTime ));
    }

    public static void main2(String[] args) {
        {
            Long startTime = System.currentTimeMillis() ;
            ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
            Map<Integer,Future<String>> map =  new HashMap<>();
            for (int i = 0; i < 20; i++) {
                System.out.println("开始循环处理 name"+i);
                TaskCallable taskCallable = new TaskCallable("name"+i);
                map.put(i, executor.submit(taskCallable) );// put进去后就走下一个循环了，不用等待submit结果了，相当于异步
            }
            for (int i = 0; i < map.size(); i++) {
                try {
                    // 添加了循环获取Future<String>结果集合，就会在当前for循环里面等待每一个task的submit执行结果了
                    System.out.println("name"+i+" 执行结果 ："+map.get(i).get());
                    //将主线程变为等待所有线程任务执行完成了后的同步线程了
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (ExecutionException e) {
                    e.printStackTrace();
                }
            }
            //扩大newFixedThreadPool的线程数， 就会加速执行
            System.out.println("耗时==="+( System.currentTimeMillis()-startTime ));
        }

    }
}

执行器调用submit()方法执行任务之后，返回一个Future类型对象。Future是一个异步任务的结果。意思就是任务交给执行器后，执行器就会立刻返回一个Future对象，而此时任务正在执行中。Future对象声明了一些方法来获取由Callable对象产生的结果，并管理他们的状态

完成

## ***补充：***

线程执行器的四种实例方式
前面提到由于ThreadPoolExecutor类的构造函数比较难记忆（参数多，形式也差不多），Java提供了一个工厂类Executors来实现执行器对象的创建。具体函数如下：

![在这里插入图片描述](https://img-blog.csdnimg.cn/20200823132117993.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI5NDA4OTk5,size_16,color_FFFFFF,t_70#pic_center)


这些函数以new开头。
1、newCachedThreadPool()：缓存线程池
1  public static ExecutorService newCachedThreadPool() {
         return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                       60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
     }
需要注意的地方：
      如果需要执行新任务，缓存线程池就会创建新线程；如果线程所运行的任务执行完成后并且这个线程可用，那么缓存线程池将会重用这些线程。
      优点：减少了创建新线程所花费的时间
      缺点：如果任务过多，系统的负荷会过载
      使用条件：线程数量合理（不太多）或者线程运行只会运行很短的时间 
2、newFixedThreadPool()：固定线程池，(fixed：固定)
public static ExecutorService newFixedThreadPool(int nThreads) {
         return new ThreadPoolExecutor(nThreads, nThreads,
                                       0L, TimeUnit.MILLISECONDS,
                                       new LinkedBlockingQueue<Runnable>());
     }
需要注定的地方：
        创建了具有线程最大数量值（即线程数量 <= nThreads）的执行器。如果发送超过数量的任务给执行器，剩余的任务将被阻塞知道线程池中有可空闲的线程来处理它们。
3、newSingleThreadExecutor():单线程执行器

 public static ExecutorService newSingleThreadExecutor() {
         return new FinalizableDelegatedExecutorService
             (new ThreadPoolExecutor(1, 1,
                                     0L, TimeUnit.MILLISECONDS,
                                     new LinkedBlockingQueue<Runnable>()));
 }

4、newScheduledThreadPool(int corePoolSize):定时执行器
 public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
         return new ScheduledThreadPoolExecutor(corePoolSize);
 }
需要注意的地方：
        使用方式如下：
 ScheduledExecutorService executor=(ScheduledExecutorService)Executors.newScheduledThreadPool(1);
 executor.schedule(task,i+1 , TimeUnit.SECONDS);
其中：task是实现了Callable接口的任务。schedule的参数含义：
 public <V> ScheduledFuture<V> schedule(Callable<V> callable,//即将执行的任务
                                            long delay,//任务执行前需要等待的时间
                                            TimeUnit unit)//时间单位

多线程在需要返回值时，我们知道需要用到Callable和Future。Callable的cell方法可以返回一个值并且可抛出异常，是对Runnable的很好的补充；Future表示了一个任务的周期，它提供了判断任务状态、获取任务结果和取消任务等方法 。
下面演示三种使用Executor执行Callable任务的方法。

     /**
     * 测试任务，返回任务的序号
     */
    public static class TestTask implements Callable<Integer>{
        int index;
        public TestTask(int index) {
            this.index = index;
        }
        @Override
        public Integer call() throws Exception {
            return index;
        }
    }

/**
     * 方法一：手动的保存任务的返回，这样的好处是每个任务对应的结果我们很清楚
     */
    @Test
    public void ordinaryTest() throws ExecutionException, InterruptedException {
        ExecutorService es = Executors.newFixedThreadPool(10);
        List<Future<Integer>> futures = new ArrayList<>();
        for(int i = 0; i < 10; i++) {
            TestTask testTask = new TestTask(i);
            Future<Integer> future = es.submit(testTask);
            futures.add(future);
        }
        es.shutdown();
        for(int i = 0; i < 10; i++) {
            System.out.println("index:" + i + ",future:"+ futures.get(i).get());
        }
    }

   /**
    * 方法二：使用ExecutorCompletionService
    * ExecutorCompletionService中使用阻塞队列保存各任务的返回结果，返回是无序的，即谁先执行完成（异常、中断），谁先入队。
    * 当我们不关心结果的顺序，或者需要一个任务完成时就取消其他任务的情况下，它是非常的方便的
    */
   @Test
   public void completionServiceTest() throws ExecutionException, InterruptedException {
       ExecutorService es = Executors.newFixedThreadPool(10);
       CompletionService<Integer> completionService = new ExecutorCompletionService<>(es);
       for(int i = 0; i < 10; i++) {
           TestTask testTask = new TestTask(i);
           completionService.submit(testTask);
       }
       es.shutdown();
       for(int i = 0; i < 10; i++) {
           Future<Integer> future = completionService.take();
           System.out.println("index:" + i + ",future:"+ future.get());
       }
   }

    /**
     * 方法三：ExecutorService的invokeAll方法
     * invokeAll方法入参为一组任务，返回一组Future，这两个集合是有相同结构的，
     * 即它是按照入参的任务集合中迭代器的顺序将所有的Future添加到返回的集合中，从而任务和Future在它们各自的集合中有着同样的顺序。
     * 当我们需要任务和结果的对应关系时，使用invokeAll方法来代替第一种方法
     */
    @Test
    public void invokeAllTest() throws InterruptedException, ExecutionException {
        ExecutorService es = Executors.newFixedThreadPool(10);
        List<TestTask> tasks = new ArrayList<>();
        for (int i = 0; i < 10; i++){
            tasks.add(new TestTask(i));
        }
        List<Future<Integer>> futures = es.invokeAll(tasks);
        es.shutdown();
        for (int i = 0; i < futures.size(); i++){
            System.out.println("index:" + i + ",future:"+ futures.get(i).get());
        }
    }

下面看一下ExecutorCompletionService的原理：
ExecutorCompletionService是将Executor和BlockingQueue的功能融合在一起，可将Callbale任务提交给它来执行，然后我们就可以像队列一样使用take或poll来得到已经完成的任务结果。下面是源码分析：

    /**
     *ExecutorCompletionService包含三个成员变量，最主要的是completionQueue，它的类型阻塞队列
     */
 
    private final Executor executor;
    private final AbstractExecutorService aes;
    private final BlockingQueue<Future<V>> completionQueue;
 
    /**
     * 构造方法，需要我们传入一个Executor
     */
    public ExecutorCompletionService(Executor executor) {
        if (executor == null)
            throw new NullPointerException();
        this.executor = executor;
        this.aes = (executor instanceof AbstractExecutorService) ?
                (AbstractExecutorService) executor : null;
        this.completionQueue = new LinkedBlockingQueue<Future<V>>();
    }
 
    /**
     * 提交任务的方法，其中的RunnableFuture为一个内部类，继承自FutureTask
     */
    public Future<V> submit(Callable<V> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<V> f = newTaskFor(task);
        executor.execute(new QueueingFuture(f));
        return f;
    }
    private class QueueingFuture extends FutureTask<Void> {
        QueueingFuture(RunnableFuture<V> task) {
            super(task, null);
            this.task = task;
        }
 
        /**
         * 这是QueueingFuture存在的主要原因，当任务执行完成后，将任务结果装入队列中
         */
        protected void done() { completionQueue.add(task); }
        private final Future<V> task;
    }
 
    /**
     * 从队列中获取返回值
     */
    public Future<V> take() throws InterruptedException {
        return completionQueue.take();
    }

转载于:https://my.oschina.net/u/2424727/blog/2032393

http://www.infoq.com/cn/articles/executor-framework-thread-pool-task-execution-part-01

一、前言
1.5后引入的Executor框架的最大优点是把任务的提交和执行解耦。要执行任务的人只需把Task描述清楚，然后提交即可。这个Task是怎么被执行的，被谁执行的，什么时候执行的，提交的人就不用关心了。具体点讲，提交一个Callable对象给ExecutorService（如最常用的线程池ThreadPoolExecutor），将得到一个Future对象，调用Future对象的get方法等待执行结果就好了。

经过这样的封装，对于使用者来说，提交任务获取结果的过程大大简化，调用者直接从提交的地方就可以等待获取执行结果。而封装最大的效果是使得真正执行任务的线程们变得不为人知。有没有觉得这个场景似曾相识？我们工作中当老大的老大（且称作LD^2）把一个任务交给我们老大（LD）的时候，到底是LD自己干，还是转过身来拉来一帮苦逼的兄弟加班加点干，那LD^2是不管的。LD^2只用把人描述清楚提及给LD，然后喝着咖啡等着收LD的report即可。等LD一封邮件非常优雅地报告LD^2report结果时，实际操作中是码农A和码农B干了一个月，还是码农ABCDE加班干了一个礼拜，大多是不用体现的。这套机制的优点就是LD^2找个合适的LD出来提交任务即可，接口友好有效，不用为具体怎么干费神费力。

二、 一个最简单的例子
看上去这个执行过程是这个样子。调用这段代码的是老大的老大了，他所需要干的所有事情就是找到一个合适的老大（如下面例子中laodaA就荣幸地被选中了），提交任务就好了。

// 一个有7个作业线程的线程池，老大的老大找到一个管7个人的小团队的老大
       ExecutorService laodaA = Executors.newFixedThreadPool(7);
         //提交作业给老大，作业内容封装在Callable中，约定好了输出的类型是String。
            String outputs = laoda.submit(
                     new Callable<String>() {
                         public String call() throws Exception 
                         {                          
                             return "I am a task, which submited by the so called laoda, and run by those anonymous workers";
                         }
                         //提交后就等着结果吧，到底是手下7个作业中谁领到任务了，老大是不关心的。
                     }).get();

            System.out.println(outputs);

使用上非常简单，其实只有两行语句来完成所有功能：创建一个线程池，提交任务并等待获取执行结果。

例子中生成线程池采用了工具类Executors的静态方法。除了newFixedThreadPool可以生成固定大小的线程池，newCachedThreadPool可以生成一个无界、可以自动回收的线程池，newSingleThreadScheduledExecutor可以生成一个单个线程的线程池。newScheduledThreadPool还可以生成支持周期任务的线程池。一般用户场景下各种不同设置要求的线程池都可以这样生成，不用自己new一个线程池出来。

三、代码剖析
这套机制怎么用，上面两句语句就做到了，非常方便和友好。但是submit的task是怎么被执行的？是谁执行的？如何做到在调用的时候只有等待执行结束才能get到结果。这些都是1.5之后Executor接口下的线程池、Future接口下的可获得执行结果的的任务，配合AQS和原有的Runnable来做到的。在下文中我们尝试通过剖析每部分的代码来了解Task提交，Task执行，获取Task执行结果等几个主要步骤。为了控制篇幅，突出主要逻辑，文章中引用的代码片段去掉了异常捕获、非主要条件判断、非主要操作。文中只是以最常用的ThreadPoolExecutor线程池举例，其实ExecutorService接口下定义了很多功能丰富的其他类型，有各自的特点，但风格类似。本文重点是介绍任务提交的过程，过程中涉及的ExecutorService、ThreadPoolExecutor、AQS、Future、FutureTask等只会介绍该过程中用到的内容，不会对每个类都详细展开。

1、 任务提交

从类图上可以看到，接口ExecutorService继承自Executor。不像Executor中只定义了一个方法来执行任务，在ExecutorService中，正如其名字暗示的一样，定义了一个服务，定义了完整的线程池的行为，可以接受提交任务、执行任务、关闭服务。抽象类AbstractExecutorService类实现了ExecutorService接口，也实现了接口定义的默认行为。

AbstractExecutorService任务提交的submit方法有三个实现。第一个接收一个Runnable的Task，没有执行结果；第二个是两个参数：一个任务，一个执行结果；第三个一个Callable，本身就包含执任务内容和执行结果。 submit方法的返回结果是Future类型，调用该接口定义的get方法即可获得执行结果。 V get() 方法的返回值类型V是在提交任务时就约定好了的。

除了submit任务的方法外，作为对服务的管理，在ExecutorService接口中还定义了服务的关闭方法shutdown和shutdownNow方法，可以平缓或者立即关闭执行服务，实现该方法的子类根据自身特征支持该定义。在ThreadPoolExecutor中，维护了RUNNING、SHUTDOWN、STOP、TERMINATED四种状态来实现对线程池的管理。线程池的完整运行机制不是本文的重点，重点还是关注submit过程中的逻辑。

1) 看AbstractExecutorService中代码提交部分，构造好一个FutureTask对象后，调用execute()方法执行任务。我们知道这个方法是顶级接口Executor中定义的最重要的方法。。FutureTask类型实现了Runnable接口，因此满足Executor中execute()方法的约定。同时比较有意思的是，该对象在execute执行后，就又作为submit方法的返回值返回，因为FutureTask同时又实现了Future接口，满足Future接口的 public Future submit(Callable task) {
if (task == null) throw new NullPointerException();
RunnableFuture ftask = newTaskFor(task);
execute(ftask);
return ftask;
}Submit传入的参数都被封装成了FutureTask类型来execute的，对应前面三个不同的参数类型都会封装成FutureTask。
protected RunnableFuture newTaskFor(Callable callable) {
return new FutureTask(callable);
}Executor接口中定义的execute方法的作用就是执行提交的任务，该方法在抽象类AbstractExecutorService中没有实现，留到子类中实现。我们观察下子类ThreadPoolExecutor，使用最广泛的线程池如何来execute那些submit的任务的。这个方法看着比较简单，但是线程池什么时候创建新的作业线程来处理任务，什么时候只接收任务不创建作业线程，另外什么时候拒绝任务。线程池的接收任务、维护工作线程的策略都要在其中体现。

作为必要的预备知识，先补充下ThreadPoolExecutor有两个最重要的集合属性，分别是存储接收任务的任务队列和用来干活的作业集合。

//任务队列
private final BlockingQueue workQueue;
//作业线程集合
private final HashSet workers = new HashSet();
其中阻塞队列workQueue是来存储待执行的任务的，在构造线程池时可以选择满足该BlockingQueue 接口定义的SynchronousQueue、LinkedBlockingQueue或者DelayedWorkQueue等不同阻塞队列来实现不同特征的线程池。

关注下execute(Runnable command)方法中调用到的addIfUnderCorePoolSize，workQueue.offer(command) ， ensureQueuedTaskHandled(command)，addIfUnderMaximumPoolSize(command)这几个操作。尤其几个名字较长的private方法，把方法名的驼峰式的单词分开，加上对方法上下文的了解就能理解其功能。

因为前面说到的几个方法在里面即是操作，又返回一个布尔值，影响后面的逻辑，所以不大方便在方法体中为每条语句加注释来说明，需要大致关联起来看。所以首先需要把execute方法的主要逻辑说明下，再看其中各自方法的作用。

如果线程池的状态是RUNNING，线程池的大小小于配置的核心线程数，说明还可以创建新线程，则启动新的线程执行这个任务。
如果线程池的状态是RUNNING ，线程池的大小小于配置的最大线程数，并且任务队列已经满了，说明现有线程已经不能支持当前的任务了，并且线程池还有继续扩充的空间，就可以创建一个新的线程来处理提交的任务。
如果线程池的状态是RUNNING，当前线程池的大小大于等于配置的核心线程数，说明根据配置当前的线程数已经够用，不用创建新线程，只需把任务加入任务队列即可。如果任务队列不满，则提交的任务在任务队列中等待处理；如果任务队列满了则需要考虑是否要扩展线程池的容量。
当线程池已经关闭或者上面的条件都不能满足时，则进行拒绝策略，拒绝策略在RejectedExecutionHandler接口中定义，可以有多种不同的实现。
上面其实也是对最主要思路的解析，详细展开可能还会更复杂。简单梳理下思路：构建线程池时定义了一个额定大小，当线程池内工作线程数小于额定大小，有新任务进来就创建新工作线程，如果超过该阈值，则一般就不创建了，只是把接收任务加到任务队列里面。但是如果任务队列里的任务实在太多了，那还是要申请额外的工作线程来帮忙。如果还是不够用就拒绝服务。这个场景其实也是每天我们工作中会碰到的场景。我们管人的老大，手里都有一定HC（Head Count），当上面老大有活分下来，手里人不够，但是不超过HC，我们就自己招人；如果超过了还是忙不过来，那就向上门老大申请借调人手来帮忙；如果还是干不完，那就没办法了，新任务咱就不public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
if (runState == RUNNING && workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);
}
else if (!addIfUnderMaximumPoolSize(command))
reject(command); // is shutdown or saturated
}
}
4) addIfUnderCorePoolSize方法检查如果当前线程池的大小小于配置的核心线程数，说明还可以创建新线程，则启动新的线程执行这个任务。

private boolean addIfUnderCorePoolSize(Runnable firstTask) {
Thread t = null;
//如果当前线程池的大小小于配置的核心线程数，说明还可以创建新线程
if (poolSize < corePoolSize && runState == RUNNING)
// 则启动新的线程执行这个任务
t = addThread(firstTask);
return t != null;
} 和上一个方法类似，addIfUnderMaximumPoolSize检查如果线程池的大小小于配置的最大线程数，并且任务队列已经满了（就是execute方法试图把当前线程加入任务队列时不成功），说明现有线程已经不能支持当前的任务了，但线程池还有继续扩充的空间，就可以创建一个新的线程来处理提交的任务。

private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {
// 如果线程池的大小小于配置的最大线程数，并且任务队列已经满了（就
是execute方法中试图把当前线程加入任务队列workQueue.offer(command)时候不成功
）,说明现有线程已经不能支持当前的任务了，但线程池还有继续扩充的空间
if (poolSize < maximumPoolSize && runState == RUNNING)
//就可以创建一个新的线程来处理提交的任务
t = addThread(firstTask);
return t != null;
} 在ensureQueuedTaskHandled方法中，判断如果当前状态不是RUNING，则当前任务不加入到任务队列中，判断如果状态是停止，线程数小于允许的最大数，且任务队列还不空，则加入一个新的工作线程到线程池来帮助处理还未处理完的任务。

private void ensureQueuedTaskHandled(Runnable command) {
            //  如果当前状态不是RUNING，则当前任务不加入到任务队列中，判断如
果状态是停止，线程数小于允许的最大数，且任务队列还不空
             if (state < STOP &&
                     poolSize < Math.max(corePoolSize, 1) &&
                     !workQueue.isEmpty())
            //则加入一个新的工作线程到线程池来帮助处理还未处理完的任务
                t = addThread(null);
        if (reject)
            reject(command);
    }

7) 在前面方法中都会调用adThread方法创建一个工作线程，差别是创建的有些工作线程上面关联接收到的任务firstTask，有些没有。该方法为当前接收到的任务firstTask创建Worker，并将Worker添加到作业集合HashSet workers中，并启动作业。

private Thread addThread(Runnable firstTask) {
        //为当前接收到的任务firstTask创建Worker
        Worker w = new Worker(firstTask);
        Thread t = threadFactory.newThread(w);
            w.thread = t;
       //将Worker添加到作业集合HashSet<Worker> workers中，并启动作业
            workers.add(w);
                t.start();
        return t;
    }

至此，任务提交过程简单描述完毕，并介绍了任务提交后ExecutorService框架下线程池的主要应对逻辑，其实就是接收任务，根据需要创建或者维护管理线程。

维护这些工作线程干什么用？先不用看后面的代码，想想我们老大每月辛苦地把老板丰厚的薪水递到我们手里，定期还要领着大家出去happy下，又是定期的关心下个人生活，所有做的这些都是为什么呢？木讷的代码工不往这边使劲动脑子，但是猜还是能猜的到的，就让干活呗。本文想着重表达细节，诸如线程池里的Worker是怎么工作的，Task到底是不是在这些工作线程中执行的，如何保证执行完成后，外面等待任务的老大拿到想要结果，我们将在下篇文章中详细介绍

戏（细）说Executor框架线程池任务执行全过程（下）
http://www.infoq.com/cn/articles/executor-framework-thread-pool-task-execution-part-02?utm_source=infoq&utm_campaign=user_page&utm_medium=link