线程池ThreadPoolExecutor解析

线程池状态含义

RUNNING 接受新任务并且处理阻塞队列里的任务
SHUTDOWN ：拒绝新任务但是处理阻 队列里的任务
STOP ：拒绝新任务并且 抛弃阻塞队列 的任务 ，同时会中断正在处理的任务。
TIDYING 所有任务都执行完（包含阻 队列里面的任务）后当前线程池活动线程数为0 将要调用 terminated 方法
TERMINATED 终止状态， terminated 方法调用完成 以后的状态

线程池状态转换

RUNNING -> SHUTDOWN：由接收新任务变为拒绝新的任务，但是还是会处理阻塞队列里的任务 显式调用 shutdown方法 或者隐式调用了 finalize方法里面的 shutdown方法
RUNNING或 SHUTDOWN -> STOP ：拒绝新任务并且抛弃阻塞队列并且终止正在执行的任务。显式调用 shutdownNow（） 方法
SHUTDOWN->TIDYING 当线程池和任务队列都为空时；
STOP -> TIDYING 当线程池为空时
TIDY G -> TERM ATED terminated() hook 方法执行完成

线程池参数

corePoolSize ：线程池 核心线程数
workQueue ：用于保存等待执行的任务的阻塞队列，比如基于数组的有界
ArrayBlockingQueue 、基于链表的无界 LinkedBlockingQueu 、最多只有1个元素的同步队列 SynchronousQueue 及优先级队列 PriorityBlockingQueue等。
maximunPoolSize 线程池最大线程数量。
ThreadFactory ：创建线程的工厂
RejectedExecutionHandler ：饱和策略队列满并且线程个数达到 maximunPoolSize后采取 策略，
比如 AbortPolicy （抛出异常)
CallerRunsPolicy （使用调用者所在线程来运行务);
DiscardOldestPolicy （调用 poll 丢弃1个任务，执行当前任务）
DiscardPolicy （默默丢弃，不抛出异常)
keeyAliveTime ：存活时间 如果当前线程池中的线程数量比核心线程数 ，并闲置状态， 则这些闲置的线程能存活的最大时间
TimeUnit: 存活时间的时间单位

线程池提交任务的 execute 方法

 public void execute(Runnable command) {
       //任务为空直接抛出异常
        if (command == null)
            throw new NullPointerException();
            //获取线程池状态和线程数
        int c = ctl.get();
        //当前线程池中线程个数是否小于corePoolSize ，小于则开启新线程运行任务
        if (workerCountOf(c) < corePoolSize) {
        //添加新的线程数，执行任务
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
		//如果线程池处于RUNNING状态，则添加任务到阻塞队列
        if (isRunning(c) && workQueue.offer(command)) {
        //再次检查
            int recheck = ctl.get();
            //如果状态不为RUNNING，从队列里删除该任务，执行拒绝策略
            if (! isRunning(recheck) && remove(command))
                reject(command);
               // 否则如果当前线程池为空则添加1个线程
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //如果队列满新增线程
        else if (!addWorker(command, false))
        //如果新增失败则执行拒绝策略
            reject(command);
    }

新增线程的 addWorkd（）方法

：第一部分双重循环的目的是通过 CAS 操作增加线程数：
第二部分主要是把并发安全的任务 加到 workers 里面，并且启动任务执行

    private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (int c = ctl.get();;) {
            // 检查队列是否只在必要时为空.
            if (runStateAtLeast(c, SHUTDOWN)
                && (runStateAtLeast(c, STOP)
                    || firstTask != null
                    || workQueue.isEmpty()))
                return false;

           //循环CAS增加线程个数
            for (;;) {
                //如果线程个数超限则返回false
                if (workerCountOf(c)
                    >= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
                    return false;
                    //CAS增加线程个数 ，同时只有一个线程成功
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                // CAS 失败了，则看线程池状态是否变化了，变化则跳到外层循环重新尝试获取线程池
                //状态，否则内层循环重新CAS
                if (runStateAtLeast(c, SHUTDOWN))
                    continue retry;
            }
        }
        //到这里说明 CAS 添加线程成功了,开始添加worker 添加成功调用线程的start执行任务
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
        //创建worker
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
            //加独占锁，为了实现workers 同步，因为可能多个线程可能同时调用了线程池 execute
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // 在锁定时重新检查.
                    // 在ThreadFactory失败时退出
                    // 在获得锁之前关闭
                    int c = ctl.get();
                    if (isRunning(c) ||
                        (runStateLessThan(c, STOP) && firstTask == null)) {
                        if (t.getState() != Thread.State.NEW)
                            throw new IllegalThreadStateException();
                            //添加worker
                        workers.add(w);
                        workerAdded = true;
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                    }
                } finally {
                    mainLock.unlock();
                }
                //添加成功后则启动任务
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

新增线程后执行task任务调用 runWorker()方法
新增一个线程就会创建一个包装对象worker ；创建后 调用worker 的runWorker()方法来执行任务
该方法会while循环从阻塞队列里取task任务。getTask()方法会更具是核心线程还是非核心线程来执行不同的方法
核心线程执行workQueue.take()方法。该方法是当队列任务数 =0时执行contion.await()方法，该方法会时该线程一直等待；
非核心线程执行workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) 。该方法是当队列任务数=0时执行超时等待方法 contion.awaitNanos(nanos) ，在使线程等待我们创建的线程池时设置的非核心线程的时间后，非核心线程不再等待，方法返回，非核心线程执行完毕结束销毁。

 final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
           /*当新建线程时，task 不为空，直接进入循环。当线程执行完该任务后task==null 然后执行getTask()方法从阻塞队列里获取task
           */
            while (task != null || (task = getTask()) != null) { 
                w.lock();
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                    //执行任务的run方法 走getTask()
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                //task执行完赋值给null保证下次还从阻塞队列的里取
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

//从阻塞队列获取任务
    private Runnable getTask() {
    //省略一些代码
     Runnable r = timed ?
      workQueue.poll(keepAliveTime, TimeUnit.NANOSE CONDS)  //非核心线程执行poll方法，执行超时等待，保证无任务后销毁
       :workQueue.take();                                   //核心线程执行take方法，一直等待保证核心线程不会销毁
     }
     
     //非核心线程的poll方法
    public E poll(long timeout, TimeUnit unit) throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0) {
                if (nanos <= 0)
                    return null;
                nanos = notEmpty.awaitNanos(nanos);   //执行超时等待，超时时间过后re
            }
            return dequeue();                         //任务不为空 返回任务
        } finally {
            lock.unlock();
        }
    }
    //核心线程的take方法
     public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();//一直等待
            return dequeue();    //任务不为空 返回任务
        } finally {
            lock.unlock();
        }
    }