线程池

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,Executors.defaultThreadFactory(), defaultHandler);
}

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,threadFactory, defaultHandler);
}


public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,Executors.defaultThreadFactory(), handler);
}

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;
}

ThreadPoolExecutor.AbortPolicy;//丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy;//也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy;//丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy;//由调用线程处理该任务
//当然也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化不能处理的任务。

public class WorkerThread implements Runnable {
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("thread:" + Thread.currentThread().getName() + "is finished.");
    }
}

public class NewSingleThreadExecutorLearn {
    public static void main(String[] args) {
        //newFixedThreadPool
        ExecutorService service = Executors.newSingleThreadExecutor();
        for (int i = 0 ;i< 20;i++) {
            Thread thread = new Thread(new WorkerThread(), "thread:"+i);
            service.execute(thread);
        }
        service.shutdown();
    }
}

  thread:pool-1-thread-1is finished.
  thread:pool-1-thread-1is finished.
  thread:pool-1-thread-1is finished.
  thread:pool-1-thread-1is finished.
  ...

public class FixedThreadExecutorLearn {
    public static void main(String[] args) {
        //newFixedThreadPool
        ExecutorService service = Executors.newFixedThreadPool(3);
        for (int i = 0 ;i< 2000;i++) {
            Thread thread = new Thread(new WorkerThread(), "thread:"+i);
            service.execute(thread);
        }
        service.shutdown();
    }
}

thread:pool-1-thread-3is finished.
thread:pool-1-thread-1is finished.
thread:pool-1-thread-2is finished.
thread:pool-1-thread-2is finished.
thread:pool-1-thread-1is finished.
thread:pool-1-thread-3is finished.
thread:pool-1-thread-1is finished.
thread:pool-1-thread-3is finished.
thread:pool-1-thread-2is finished.
...

public class NewCachedThreadPoolLearn {
    public static void main(String[] args) {
        //newFixedThreadPool
        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0 ;i< 20;i++) {
            Thread thread = new Thread(new WorkerThread(), "thread:"+i);
            service.execute(thread);
        }
        service.shutdown();
    }
}

thread:pool-1-thread-1is finished.
thread:pool-1-thread-3is finished.
thread:pool-1-thread-11is finished.
thread:pool-1-thread-10is finished.
thread:pool-1-thread-6is finished.
thread:pool-1-thread-7is finished.
thread:pool-1-thread-4is finished.
thread:pool-1-thread-8is finished.
thread:pool-1-thread-9is finished.
thread:pool-1-thread-5is finished.
thread:pool-1-thread-2is finished.
thread:pool-1-thread-12is finished.
thread:pool-1-thread-19is finished.
thread:pool-1-thread-20is finished.
...

//利用低29位表示线程池中线程数，通过高3位表示线程池的运行状态：
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));   

//32-3 = 29 ，低位29位存储线程池中线程数
private static final int COUNT_BITS = Integer.SIZE - 3;   
//线程池最多可以有536870911个线程，一般绝对创建不到这么大
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

//RUNNING线程池能接受新任务（只有running状态才会接收新任务），并且可以运行队列中的任务
//-1的二进制为32个1，移位后为：11100000000000000000000000000000
private static final int RUNNING = -1 << COUNT_BITS;

//SHUTDOWN不再接受新任务，但仍可以执行队列中的任务
//0的二进制为32个0，移位后还是全0
private static final int SHUTDOWN = 0 << COUNT_BITS;

//STOP不再接受新任务，不再执行队列中的任务，而且要中断正在处理的任务
//1的二进制为前面31个0，最后一个1，移位后为：00100000000000000000000000000000
private static final int STOP = 1 << COUNT_BITS;

//TIDYING所有任务均已终止，workerCount的值为0，转到TIDYING状态的线程即将要执行terminated()钩子方法.
//2的二进制为01000000000000000000000000000000
private static final int TIDYING = 2 << COUNT_BITS;

//TERMINATED terminated()方法执行结束.
//3移位后01100000000000000000000000000000
private static final int TERMINATED = 3 << COUNT_BITS;

/获取线程池的状态,也就是将ctl低29位都置为0后的值
private static int runStateOf(int c)     { return c & ~CAPACITY; }
//获取线程池中线程数，也就是ctl低29位的值
private static int workerCountOf(int c)  { return c & CAPACITY; }  
//设置ctl的值，rs为线程池状态，wc为线程数；
private static int ctlOf(int rs, int wc) { return rs | wc; }     

/**
 * Set containing all worker threads in pool. Accessed only when
 * holding mainLock.
 * 用来存储线程池中的线程，线程都被封装成了Worker对象
 */
private final HashSet<Worker> workers = new HashSet<Worker>();

//添加新任务
public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
     //获取当前线程池的ctl值. --> AtomicInteger ctl
    int c = ctl.get();

    //如果当前线程数小于核心线程数，这时候任务不会进入任务队列，会创建新的工作线程直接执行任务；
    if (workerCountOf(c) < corePoolSize) {
      //添加新的工作线程执行任务，addWorker方法后面分析
        if (addWorker(command, true))
            return;
        //addWorker操作返回false，说明添加新的工作线程失败，则获取当前线程池状态；
        //线程池数量小于corePoolSize情况下，创建新的工作线程失败，是因为线程池的状态发生了改变，已经处于非Running状态，或shutdown状态且任务队列为空
        c = ctl.get();
    }


    //以下两种情况继续执行后面代码
    //1.前面的判断中，线程池中线程数小于核心线程数，并且创建新的工作线程失败；
    //2.前面的判断中，线程池中线程数大于等于核心线程数

    //线程池处于RUNNING状态，说明线程池中线程已经>=corePoolSize,这时候要将任务放入队列中，等待执行;
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        //再次检查线程池的状态，如果线程池状态变了，非RUNNING状态下不会接收新的任务，需要将任务移除，成功从队列中删除任务，则执行reject方法处理任务；
        if (! isRunning(recheck) && remove(command))
            reject(command);
        //如果线程池的状态没有改变，且池中无线程
        else if (workerCountOf(recheck) == 0)
        // 两种情况进入以该分支
        //1.线程池处于RUNNING状态，线程池中没有线程了，因为有新任务进入队列所以要创建工作线程（这时候新任务已经在队列中，所以下面创建worker线程时第一个参数，要执行的任务为null，只是创建一个新的工作线程并启动它，让它自己去队列中取任务执行）
        //2.线程池处于非RUNNING状态但是任务移除失败,导致任务队列中仍然有任务，但是线程池中的线程数为0，则创建新的工作线程，处理队列中的任务；
            addWorker(null, false);
    }

    // 两种情况执行下面分支：
    // 1.非RUNNING状态拒绝新的任务,并且无法创建新的线程，则拒绝任务
    // 2.线程池处于RUNNING状态，线程池线程数量已经大于等于coresize，任务就需要放入队列，如果任务入队失败，说明队列满了，则创建新的线程，创建成功则新线程继续执行任务，如果创建失败说明线程池中线程数已经超过maximumPoolSize，则拒绝任务      
    else if (!addWorker(command, false))
        reject(command);
}

private boolean addWorker(Runnable firstTask, boolean core) {
    //以下for循环，增加线程数计数，ctl，只增加计数，不增加线程，只有增加计数成功，才会增加线程
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
        //这个代码块的判断，如果是STOP，TIDYING和TERMINATED这三种状态，都会返回false。(这几种状态不会接收新任务，也不再执行队列中的任务，中断当前执行的任务)
        //如果是SHUTDOWN，firstTask不为空（SHUTDOWN状态下，不会接收新任务）或 者workQueue是空（队列里面都没有任务了，也就不需要线程了），返回false。
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;
        //只有满足以下两种条件才会继续创建worker线程对象
        //1.RUNNING状态，
        //2.shutdown状态，且firstTask为null（因为shutdown状态下不再接收新任务），队列不是空（shutdown状态下需要继续处理队列中的任务）
        // 通过自旋的方式增加线程池线程数
        for (;;) {
            int wc = workerCountOf(c);
            //1.如果线程数大于最大可创建的线程数CAPACITY，直接返回false；
            //2.判断当前是要根据corePoolSize，还是maximumPoolSize进行创建线程（corePoolSize是基本线程池大小，未达到corePoolSize前按照corePollSize来限制线程池大小,达到corePoolSize后，并且任务队列也满了，才会按照maximumPoolSize限制线程池大小）
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            if (compareAndIncrementWorkerCount(c))//将WorkerCount通过CAS操作增加1，成功的话直接跳出两层循环；
                break retry;
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)//否则则判断当前线程池的状态，如果现在获取到的状态与进入自旋的状态不一致的话，那么则通过continue retry重新进行状态的判断
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }

    //以下代码块是创建Worker线程对象，并启动

    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        w = new Worker(firstTask); //创建一个新的Worker对象
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock(); //获取线程池的重入锁后，
            try {
                // Recheck while holding lock.
                // Back out on ThreadFactory failure or if
                // shut down before lock acquired.
                int rs = runStateOf(ctl.get());

                // RUNNING状态 || SHUTDONW状态下，没有新的任务，只是处理任务队列中剩余的任务；
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    //如果线程是活动状态，直接抛出异常，因为线程刚创建，还没有执行start方法，一定不会是活动状态；
                    if (t.isAlive())
                        throw new IllegalThreadStateException();
                    // 将新启动的线程添加到线程池中
                    workers.add(w);
                    // 更新largestPoolSize的值，largestPoolSize成员变量保存线程池中创建过的线程最大数量
                    int s = workers.size();
                    //将线程池中创建过的线程最大数量，设置给largestPoolSize，可以通过getLargestPoolSize()方法获取，注意这个方法只能在 ThreadPoolExecutor中调用，Executer，ExecuterService，AbstractExecutorService中都是没有这个方法的
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            // 启动新添加的线程，这个线程首先执行firstTask，然后不停的从队列中取任务执行
            // 当等待keepAlieTime还没有任务执行则该线程结束。见runWoker和getTask方法的代码。
            if (workerAdded) {
                t.start();
                workerStarted = true;
            }
        }
    }finally {
        if (! workerStarted)
            addWorkerFailed(w);
        }
        return workerStarted;
    }
}

private final class Worker  extends AbstractQueuedSynchronizer implements Runnable{
  ...
}

//参数为Worker线程运行后第一个要执行的任务
Worker(Runnable firstTask) {
    //设置ASQ的state为-1  设置worker处于不可加锁的状态，看后面的tryAcquire方法，只有state为0时才允许加锁，worker线程运行以后才会把state置为0
    setState(-1);
    //设置第一个运行的任务
    this.firstTask = firstTask;  
    //创建线程，将this自己传入进去；getThreadFactory()见后面详解
    this.thread = getThreadFactory().newThread(this);
}

//被封装的线程，就是它自己；
 final Thread thread;
 //传入的它要执行的第一个任务，如果firstTask为空就从任务队列中取任务执行
 Runnable firstTask;
 //记录执行完成的任务数量，如果执行任务过程中出现异常，仍然会计数；
 volatile long completedTasks

    //尝试加锁方法，将状态从0设置为1；如果不是0则加锁失败,在worker线程没有启动前是-1状态，无法加锁
    //该方法重写了父类AQS的同名方法
    protected boolean tryAcquire(int unused) {
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }

    //尝试释放锁的方法，直接将state置为0
    //该方法重写了父类AQS的同名方法
    protected boolean tryRelease(int unused) {
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
    }
    //注意：tryAcquire与tryRelease是重写了AQS父类的方法，且不可以直接调用，它们被以下方法调用实现加锁解锁操作

    //加锁:acquire法是它父类AQS类的方法,会调用tryAcquire方法加锁
    public void lock()        { acquire(1); }
    //尝试加锁
    public boolean tryLock()  { return tryAcquire(1); }
    //解锁:release方法是它父类AQS类的方法，会调用tryRelease方法
    public void unlock()      { release(1); }
    //返回锁状态
    public boolean isLocked() { return isHeldExclusively(); }

final void runWorker(Worker w) {
     //当前线程
     Thread wt = Thread.currentThread();
     //获取当前Worker线程创建时，指定的第一个要执行的任务，也可以不指定任务，那么它自己就会去任务队列中取任务；
     Runnable task = w.firstTask;
     w.firstTask = null;
     // 在构造方法里面将state设置为了-1，执行该方法就将state置为了0，这样就可以加锁了，-1状态下是无法加锁的，看Worker类的tryAcquire方法
     w.unlock();
     //该变量代表任务执行是否发生异常，默认值为true发生了异常，后面会用到这个变量
     boolean completedAbruptly = true;
     try {
         //如果创建worker时传入了第一个任务，则执行第一个任务，否则 从任务队列中获取任务getTask()，getTask()后面分析；
         while (task != null || (task = getTask()) != null) {
             //线程加锁
             w.lock();
             /**
              * 先判断线程池状态是否允许继续执行任务：
              * 1.如果是stop<tidying<terminated（这种状态是不接受任务，且不执行任务的），并且线程是非中断状态
              * 2.shutingdown，runing ，处于中断状态（并复位中断标志），如果这个时候其它线程执行了shutdownNow方法，shutdownNow方法会把状态设置为STOP
              *
              * 这个时候则中断线程
              **/
             if ((   
                     runStateAtLeast(ctl.get(), STOP) ||
                     (
                         Thread.interrupted() && runStateAtLeast(ctl.get(), STOP)
                     )

                 )
                  &&
                 !wt.isInterrupted())
                 wt.interrupt();
             /**
              *开始执行任务
              */
             try {
                 //任务执行前要做的处理：这个方法是空的，什么都不做，一般会通过继承ThreadPoolExecute类后重写该方法实现自己的功能；传入参数为当前线程与要执行的任务
                 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 {
                     //任务执行后要做的处理：这个方法也是空的，什么都不做,一般会通过继承ThreadPoolExecute类后重写该方法实现自己的功能；参数为当前任务和执行任务时抛出的异常
                     afterExecute(task, thrown);
                 }
             } finally {
                 task = null;
                 //增加完成任务计数
                 w.completedTasks++;   
                 w.unlock();
             }
         }
         /**
          *退出while循环，线程结束；
          **/
         //判断task.run()方法是否抛出了异常，如果没有则设置它为false，如果发生了异常，前面会直接抛出，中断方法继续执行，就不会执行下面这句；
         completedAbruptly = false;
     } finally {
         /**
          * 线程退出后的处理
          */
         processWorkerExit(w, completedAbruptly);
     }
 }

private Runnable getTask() {
   // 如果判断当前线程池状态需要启用超时操作，那么任务队列取任务时使用的是带有超时的workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)方法，如果超时，则会将timeOut 变量设置为true，在下次执行for循环时根据timeOut来执行超时操作；
   boolean timedOut = false;  

   for (;;) {
       int c = ctl.get();
       int rs = runStateOf(c);
       /**
       * 以下分支在stop、tidying、terminated状态，或者在SHUTDOWN状态且任务队列为空时　退出当前线程
       *
       * 判断线程池状态是否允许继续获取任务：
       * RUNNING<shutdown<stop<tidying<terminated;
       * rs >= SHUTDOWN，包含两部分判断操作
       *1.如果是rs > SHUTDOWN，即状态为stop、tidying、terminated；这时不再处理队列中的任务，直接返回null
       *2.如果是rs = SHUTDOWN ，rs>=STOP不成立，这时还需要处理队列中的任务除非队列为空，没有任务要处理，则返回null
       */
       // Check if queue empty only if necessary.
       if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
           //自旋锁将ctl减1（也就是将线程池中的线程数减1）
           decrementWorkerCount();
           return null;
       }
       /**
        * 在RUNNING状态 或 shutdown状态且任务队列不为空时继续往下执行执行
        */

       /**
        *　以下做线程超时控制：
        * 启用超时控制需要满足至少一个条件
        * 1.allowCoreThreadTimeOut为true代表核心线程数可以做超时控制；
        * 2.如果当前线程数>corePoolSize核心线程数,也可以做超时控制；
        * 在以上前提下，再判断当前线程是否需要销毁:
        * 1.如果当前线程数大于maximumPoolSize，这肯定是不允许的，需要销毁当前线程；
        * 2.如果当前线程上次执行循环时，取任务操作超时，任务队列是空，需要销毁当前线程；
        */

       //获取线程池中线程数量
       int wc = workerCountOf(c);

       // timed变量用于判断是否需要进行超时控制。
       // allowCoreThreadTimeOut默认是false，也就是核心线程不允许进行超时；
       // wc > corePoolSize，表示当前线程池中的线程数量大于核心线程数量；
       // 对于超过核心线程数量的这些线程，需要进行超时控制；
       boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

       /*
       * 超时销毁线程需要先满足以下两个条件之一
       * 1. wc > maximumPoolSize的情况是因为可能在此方法执行阶段同时执行了setMaximumPoolSize方法；
       * 2. timed && timedOut 如果为true，表示当前操作需要进行超时控制，并且上次循环当前线程从任务队列中获取任务发生了超时，没有取到任务；
       *  满足上面两个条件之一的情况下，接下来判断，如果线程数量大于1，或者线程队列是空的，那么尝试将workerCount减1，减1成功则返回null，退出当前线程； 如果减1失败，则返回继续执行循环操作，重试。
       */
       if ((wc > maximumPoolSize || (timed && timedOut))
           && (wc > 1 || workQueue.isEmpty())) {
           //尝试将线程池线程数量减一
           if (compareAndDecrementWorkerCount(c))
               return null;
           //如果将线程池数量减一不成功则循环重试
           continue;
       }


       /**
        * 如果没有超时，则继续去任务队列取任务执行；
        *取任务操作
        */
       try {
           //根据timed（是否启用超时控制）来判断执行poll操作还是执行take()操作还是执行有时间限制的poll操作，并返回获取到的任务；
           Runnable r = timed ?
               workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
               workQueue.take();
           if (r != null)
               return r;
           //如果poll操作等待超时,没有取到任务；则将timeOut设置为true；
           timedOut = true;
       } catch (InterruptedException retry) {
           //如果是因为线程中断导致没有取到任务；则设置timedOut=false继续执行循环，取任务
           timedOut = false;
       }
   }
}

private void processWorkerExit(Worker w, boolean completedAbruptly) {
        // 如果任务运行异常导致则completedAbruptly=true，则将线程池worker线程数减1，如果是没有获取到任务导致的completedAbruptly=false，则会在getTask()方法里面将线程数减1;
       if (completedAbruptly)
           //自旋锁将ctl减1（也就是将线程池中的线程数减1）
           decrementWorkerCount();

       final ReentrantLock mainLock = this.mainLock;
       mainLock.lock();
       try {
           //退出前，将本线程已完成的任务数量，添加到已经完成任务的总数中；
           completedTaskCount += w.completedTasks;
           //线程队列中移除当前线程
           workers.remove(w);
       } finally {
           mainLock.unlock();
       }

       //尝试停止线程池
       tryTerminate();

      /**
       *判断是否要增加新的线程
       *如果满足以下条件则新增线程：
       * 一、当线程池是RUNNING或SHUTDOWN状态，且worker是异常结束，那么会直接addWorker；
       * 二、当线程池是RUNNING或SHUTDOWN状态，且worker是没有任务可做结束的；
       *   1.如果allowCoreThreadTimeOut=true，则判断等待队列不为空  ，且当前线程数是否小于1；
       *   2.如果allowCoreThreadTimeOut=false，则判断当前线程数是否小于小于corePoolSize；
       *   如果小于，则会创建addWorker线程；
       **/
       int c = ctl.get();
       //当线程池是RUNNING或SHUTDOWN状态，
       if (runStateLessThan(c, STOP)) {
           //如果非异常状况completedAbruptly=false，也就是没有获取到可执行的任务，则获取线程池允许的最小线程数，如果allowCoreThreadTimeOut为true说明允许核心线程超时，则最小线程数为0，否则最小线程数为corePoolSize;
           if (!completedAbruptly) {
               int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
               //如果allowCoreThreadTimeOut=true，且任务队列有任务要执行，则将最最小线程数设置为1
               if (min == 0 && ! workQueue.isEmpty())
                   min = 1;
               //如果当前线程数大于等于最小线程数，则直接返回
               if (workerCountOf(c) >= min)
                   return; // replacement not needed
           }
           //以下两种情况会添加一个新的线程
           //1.worker是异常结束；
           //2.如果是非异常结束，且任务队列里面还有任务，
           addWorker(null, false);
       }
   }

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        // 线程池状态设为SHUTDOWN，如果已经是shutdown<stop<tidying<terminated，也就是非RUNING状态则直接返回
        advanceRunState(SHUTDOWN);
        // 中断空闲的没有执行任务的线程
        interruptIdleWorkers();
        onShutdown(); //空方法，子类覆盖实现
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
}

public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        // STOP状态：不再接受新任务且不再执行队列中的任务。
        advanceRunState(STOP);
        // 中断所有线程，无论空闲还是在执行任务
        interruptWorkers();
        // 将任务队列清空，并返回队列中还没有被执行的任务。
        tasks = drainQueue();
    }finally {
        mainLock.unlock();
    }
    tryTerminate();
    return tasks;
}

protected void finalize() {
      shutdown();
}

//中断空闲线程，没有执行任务的线程会被中断，onlyOne参数用来标识是否只中断一个线程；
private void interruptIdleWorkers(boolean onlyOne) {
     final ReentrantLock mainLock = this.mainLock;
     mainLock.lock();
     try {
         //遍历所有的Worker线程
         for (Worker w : workers) {
             Thread t = w.thread;
             //如果线程没有被中断，w.tryLock()会调用tryAcquire()方法尝试加锁，加锁成功后会中断线程
             //为什么要w.tryLock(),因为在runWorker()方法的while循环执行任务之前会加锁，如果已经被加锁说明线程正在执行任务，不能被中断；
             if (!t.isInterrupted() && w.tryLock()) {
                 try {
                     //中断线程
                     t.interrupt();
                 } catch (SecurityException ignore) {
                 } finally {
                     w.unlock();
                 }
             }
             //如果 onlyOne为true， for循环只执行一次就退出
             if (onlyOne)
                 break;
         }
     } finally {
         mainLock.unlock();
     }
 }

 /****
  * 中断所有正在运行的线程，注意，这里与interruptIdelWorkers()方法不同的是，没有使用worker的AQS锁
  */
 private void interruptWorkers() {
     final ReentrantLock mainLock = this.mainLock;
     mainLock.lock();
     try {
         for (Worker w : workers)
             w.interruptIfStarted();
     } finally {
         mainLock.unlock();
     }
 }

final void tryTerminate() {
    for (;;) {
        int c = ctl.get();
        //先判断是否满足终止线程池的条件
        //1.如果线程池的状态是RUNNING（不可终止）或者是TIDYING（该状态的线程池即将要执行或正在执行terminated()钩子方法），TERMINATED（该状态已经执行完成terminated()钩子方法），直接返回。
        //2.如果线程池状态是SHUTDOWN，而且任务队列不是空的（该状态需要继续处理任务队列中的任务，不可被终止），也直接返回。
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
            return;

        //以下状态才会继续执行：
        //1.如果线程池状态是SHUTDOWN，而且任务队列是空的（shutdown状态下，任务队列为空，可以被终止），向下进行。
        //2.如果线程池状态是STOP（该状态下，不接收新任务，不执行任务队列中的任务，并中断正在执行中的线程，可以被终止），向下进行。

        // workerCount不为0则还不能停止线程池,而且这时线程都处于空闲等待的状态
        // 需要中断让线程“醒”过来，醒过来的线程才能继续处理shutdown的信号。
        if (workerCountOf(c) != 0) { // Eligible to terminate
            // runWoker方法中w.unlock就是为了可以被中断,getTask方法也处理了中断。
            // ONLY_ONE:这里只需要中断1个线程去处理shutdown信号就可以了。
            interruptIdleWorkers(ONLY_ONE);
            return;
        }

        //满足以下两个条件才会继续执行
        //1.线程池状态是STOP且 工作线程池中的线程wc是0
        //2.线程池状态是SHUTDOWN而且工作线程池wc(pool)和任务队列(queue)都是空的
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            //进入TIDYING状态，线程池的状态被原子操作ctl.compareAndSet(c, ctlOf(TIDYING, 0)将状态设置为TIDYING，(因为tryTerminate方法会在多处调用，存在竞争)
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                try {
                    terminated();
                } finally {
                    //进入TERMINATED状态
                    //进一步在terminated结束之后的finally块中通过ctl.set(ctlOf(TERMINATED, 0))设置为TERMINATED。
                    ctl.set(ctlOf(TERMINATED, 0));
                    termination.signalAll();  //最后执行termination.signalAll()，会唤醒awaitTermination方法中由于执行termination.awaitNanos(nanos)操作进入等待状态的线程
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
        // else retry on failed CAS
    }
}

public interface RejectedExecutionHandler {
    /**
     * Method that may be invoked by a {@link ThreadPoolExecutor} when
     * {@link ThreadPoolExecutor#execute execute} cannot accept a
     * task.  This may occur when no more threads or queue slots are
     * available because their bounds would be exceeded, or upon
     * shutdown of the Executor.
     *
     * <p>In the absence of other alternatives, the method may throw
     * an unchecked {@link RejectedExecutionException}, which will be
     * propagated to the caller of {@code execute}.
     *
     * @param r the runnable task requested to be executed
     * @param executor the executor attempting to execute this task
     * @throws RejectedExecutionException if there is no remedy
     */
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

  ThreadPoolExecutor pool = new ThreadPoolExecutor(10, 10, 0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(10));
  // 当前线程池中的工作线程数；也就是返回成员变量private final HashSet<Worker> workers = new HashSet<Worker>()的大小
  pool.getPoolSize();
  // 队列中的任务； 也就是返回成员变量 private final BlockingQueue<Runnable> workQueue;的大小
  pool.getQueue().size();
  // 线程正在执行的任务; 遍历workers，返回加锁的worker数量（加锁，说明这个线程正在执行任务）
  pool.getActiveCount();
  // 已经执行完成的任务； ThreadPoolExecutor.completedTaskCount+每个Worker.completedTasks ,线程池记录的完成任务数量和每个worker线程记录的完成的任务的数量；
  pool.getCompletedTaskCount();
  // 全部的任务数，队列任务+正在执行+已经执行完成
  pool.getTaskCount();
  // 核心线程数；
  pool.getCorePoolSize();
  // 最大线程数；
  pool.getMaximumPoolSize();
  // 线程池中曾经最大的线程数量；
  pool.getLargestPoolSize();
  // 线程超时时间
  pool.getKeepAliveTime(TimeUnit.SECONDS);
  // 是否允许coreThread超时；
  pool.allowsCoreThreadTimeOut();

/**
 * 连接池管理类
 *
 * @author zqz
 *
 */
public class ZQZThreadPool extends ThreadPoolExecutor {

    public static final AtomicBoolean lock = new AtomicBoolean();

    public static final Map<String, ThreadPoolExecutor> poolManager = new ConcurrentHashMap<String, ThreadPoolExecutor>();
    public static final ThreadFactory defaultThreadFactor = new DefaultThreadFactory();

    /**
     * 获取连接池实例
     *
     * @param poolName
     *            自定义连接池名称前缀 ，更好的区分不同的连接池；
     * @param corePoolSize
     *            核心线程数
     * @param maximumPoolSize
     *            最大线程数
     * @param keepAliveTime
     *            空闲线程存活时间，单位是秒
     * @param workQueue
     *            任务队列
     * @return
     */
    public static ThreadPoolExecutor getInstance(String poolName, int corePoolSize, int maximumPoolSize,
            long keepAliveTime, BlockingQueue<Runnable> workQueue) {
        while (!lock.compareAndSet(false, true))
            ;
        ThreadPoolExecutor pool = poolManager.get(poolName);
        try {
            if (pool == null) {
                pool = new ZQZThreadPool(poolName, corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.SECONDS,
                        workQueue, defaultThreadFactor);
                poolManager.put(poolName, pool);
                return pool;
            } else {
                return poolManager.get(poolName);
            }
        } finally {
            lock.compareAndSet(true, false);
        }
    }

    /**
     * 私有构造方法
     * @param poolName
     * @param corePoolSize
     * @param maximumPoolSize
     * @param keepAliveTime
     * @param unit
     * @param workQueue
     * @param threadFactory
     */
    private ZQZThreadPool(String poolName, int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
            BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
        if (!poolManager.containsKey(poolName)) {
            poolManager.put(poolName, this);
        }
    }

    /**
     * 返回指定线程池状态
     * @param name
     * @return
     */
    public static PoolInfo monitor(String name) {
        ThreadPoolExecutor pool = poolManager.get(name);
        if (pool == null)
            return null;
        PoolInfo poolInfo = new PoolInfo();

        // 当前线程池中的工作线程数；
        poolInfo.setPoolSize(pool.getPoolSize());
        // 队列中的任务；
        poolInfo.setQueueSize(pool.getQueue().size());
        // 线程正在执行的任务;
        poolInfo.setActiveCount(pool.getActiveCount());
        // 已经执行完成的任务；
        poolInfo.setCompletedTaskCount(pool.getCompletedTaskCount());
        // 是否允许coreThread超时；
        poolInfo.setAllowsCoreThreadTimeOut(pool.allowsCoreThreadTimeOut());
        // 核心线程数；
        poolInfo.setCorePoolSize(pool.getCorePoolSize());
        // 最大线程数；
        poolInfo.setMaximumPoolSize(pool.getMaximumPoolSize());
        // 线程池中曾经最大的线程数量；
        poolInfo.setLargestPoolSize(pool.getLargestPoolSize());
        // 线程超时时间
        poolInfo.setKeepAliveTime(pool.getKeepAliveTime(TimeUnit.SECONDS));
        // 全部的任务数，队列任务+正在执行+已经执行完成
        pool.getTaskCount();
        return poolInfo;
    }

    /**
     * The default thread factory
     */
    static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;
        private int stackSize = 0;

        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
            namePrefix = "zqz-pool-" + poolNumber.getAndIncrement() + "-thread-";
        }

        public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), stackSize);
            if (t.isDaemon())
                t.setDaemon(false);
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

    /**
     * 测试
     * @param args
     */
    public static void main(String[] args) {
        String poolName = "test";

        ThreadPoolExecutor pool = ZQZThreadPool.getInstance(poolName, 1, 10, 0, new ArrayBlockingQueue<Runnable>(10));

        pool.execute(new Runnable() {

            public void run() {
                System.out.println("test");
            }

        });
        PoolInfo poolInfo = ZQZThreadPool.monitor(poolName);
        System.out.println(poolInfo.getPoolSize());
    }

}