public ThreadPoolExecutor(int corePoolSize, maximumPoolSize,1)">long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
　　　　　// 注意 workQueue,threadFactory,handler 是不可以为null 的，为空会直接抛出错误
        if (workQueue == null || threadFactory == null || handler == null NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

 class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        /**
         * This class will never be serialized,but we provide a
         * serialVersionUID to suppress a javac warning.
         long serialVersionUID = 6138294804551838833L;

         Thread this worker is running in.  Null if factory fails. final Thread thread;
         Initial task to run.  Possibly null. */
        Runnable firstTask;
         Per-thread task counter volatile  completedTasks;

        
         * Creates with given first task and thread from ThreadFactory.
         * @param firstTask the first task (null if none)
         
        Worker(Runnable firstTask) {
            setState(-1);  inhibit interrupts until runWorker
            this.firstTask = firstTask;
　　　　　　　// 注意此处传入的是this
            this.thread = getThreadFactory().newThread();
        }

         Delegates main run loop to outer runWorker. */ 
　　　　　// 这里其实会调用外部的 runWorker 方法来执行自己。
         run() {
            runWorker( Lock methods
        //
         The value 0 represents the unlocked state.
         The value 1 represents the locked state.

        protected  isHeldExclusively() {
            return getState() != 0;
        }

        boolean tryAcquire( unused) {
　　　　　　　// 如果已经设置过1了，这时候在设置1就会返回false，也就是不可重入
            if (compareAndSetState(0,1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                ;
            }
            boolean tryRelease( unused) {
            setExclusiveOwnerThread();
            setState(0);
            void lock()        { acquire(1); }
        boolean tryLock()  { return tryAcquire(1void unlock()      { release(1boolean isLocked() {  isHeldExclusively(); }
　　　　　// 提供安全中断线程得方法
         interruptIfStarted() {
            Thread t;
　　　　　　　// 一开始 setstate(-1) 避免了还没开始运行就被中断可能
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                 {
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }
    }

 unused) {
    )) {
        setExclusiveOwnerThread(Thread.currentThread());
        ;
    }
    ;
}

 runWorker(Worker w) {
       Thread wt = Thread.currentThread();
       Runnable task = w.firstTask;
       w.firstTask = ;
       w.unlock();  status 设置为0，允许中断，也可以避免再次加锁失败
       boolean completedAbruptly = ;
        {
           while (task != null || (task = getTask()) != ) {
               // 要派发task的时候，需要上锁
               w.lock();
                如果线程池当前状态至少是stop，则设置中断标志;
                如果线程池当前状态是RUNNININ，则重置中断标志，重置后需要重新
               检查下线程池状态，因为当重置中断标志时候，可能调用了线程池的shutdown方法
               改变了线程池状态。
               if ((runStateAtLeast(ctl.get(),STOP) ||
                    (Thread.interrupted() &&
                     runStateAtLeast(ctl.get(),STOP))) &&
                   !wt.isInterrupted())
                   wt.interrupt();

                {
                   任务执行前干一些事情
                   beforeExecute(wt,task);
                   Throwable thrown = ;
                    {
                       task.run();执行任务
                   }  (RuntimeException x) {
                       thrown = x; throw x;
                   }  (Error x) {
                       thrown = x;  (Throwable x) {
                       thrown = x;  Error(x);
                   }  {
                       任务执行完毕后干一些事情
                       afterExecute(task,thrown);
                   }
               }  {
                   task = 统计当前worker完成了多少个任务
                   w.completedTasks++;
                   w.unlock();
               }
           }
           completedAbruptly = ;
       }  {

           执行清了工作
           processWorkerExit(w,completedAbruptly);
       }
   }

private Runnable getTask() {
     timeOut变量的值表示上次从阻塞队列中取任务时是否超时
    boolean timedOut = false;  Did the last poll() time out?
     runStateOf(c);
        
         * 如果线程池状态rs >= SHUTDOWN，也就是非RUNNING状态，再进行以下判断：
         * 1. rs >= STOP，线程池是否正在stop；
         * 2. 阻塞队列是否为空。
         * 如果以上条件满足，则将workerCount减1并返回null。
         * 因为如果当前线程池状态的值是SHUTDOWN或以上时，不允许再向阻塞队列中添加任务。
         if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            ;
        }
         workerCountOf(c);
         Are workers subject to culling?
         timed变量用于判断是否需要进行超时控制。
         allowCoreThreadTimeOut默认是false，也就是核心线程不允许进行超时；
         wc > corePoolSize，表示当前线程池中的线程数量大于核心线程数量；
         对于超过核心线程数量的这些线程，需要进行超时控制
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
        
        
         * wc > maximumPoolSize的情况是因为可能在此方法执行阶段同时执行了setMaximumPoolSize方法；
         * timed && timedOut 如果为true，表示当前操作需要进行超时控制，并且上次从阻塞队列中获取任务发生了超时
         * 接下来判断，如果有效线程数量大于1，或者阻塞队列是空的，那么尝试将workerCount减1；
         * 如果减1失败，则返回重试。
         * 如果wc == 1时，也就说明当前线程是线程池中唯一的一个线程了。
         if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
             (compareAndDecrementWorkerCount(c))
                 {
            
             * 根据timed来判断，如果为true，则通过阻塞队列的poll方法进行超时控制，如果在keepAliveTime时间内没有获取到任务，则返回null；
             * 否则通过take方法，如果这时队列为空，则take方法会阻塞直到队列不为空。
             * 
             
            Runnable r = timed ?
                workQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != )
                 r;
             如果 r == null，说明已经超时，timedOut设置为true
            timedOut = ;
        }  (InterruptedException retry) {
             如果获取任务时当前线程发生了中断，则设置timedOut为false并返回循环重试
            timedOut = ;
        }
    }
}

void processWorkerExit(Worker w,1)"> completedAbruptly) {
     如果completedAbruptly值为true，则说明线程执行时出现了异常，需要将workerCount减1；
     如果线程执行时没有出现异常，说明在getTask()方法中已经已经对workerCount进行了减1操作，这里就不必再减了。  
    if (completedAbruptly)  If abrupt,then workerCount wasn't adjusted
        decrementWorkerCount();
    .mainLock;
    mainLock.lock();
    统计完成的任务数
        completedTaskCount += w.completedTasks;
         从workers中移除，也就表示着从线程池中移除了一个工作线程
        workers.remove(w);
    }  {
        mainLock.unlock();
    }
     根据线程池状态进行判断是否结束线程池
    tryTerminate();
     ctl.get();
    
     * 当线程池是RUNNING或SHUTDOWN状态时，如果worker是异常结束，那么会直接addWorker；
     * 如果allowCoreThreadTimeOut=true，并且等待队列有任务，至少保留一个worker；
     * 如果allowCoreThreadTimeOut=false，workerCount不少于corePoolSize。
     */
     (runStateLessThan(c,STOP)) {
        completedAbruptly) {
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            if (min == 0 && ! workQueue.isEmpty())
                min = 1if (workerCountOf(c) >= min)
                return;  replacement not needed
        }
        addWorker();
    }
}

 tryTerminate() {
    
         * 当前线程池的状态为以下几种情况时，直接返回：
         * 1. RUNNING，因为还在运行中，不能停止；
         * 2. TIDYING或TERMINATED，因为线程池中已经没有正在运行的线程了；
         * 3. SHUTDOWN并且等待队列非空，这时要执行完workQueue中的task；
         if (isRunning(c) ||
            runStateAtLeast(c,TIDYING) ||
            (runStateOf(c) == SHUTDOWN && ! 如果线程数量不为0，则中断一个空闲的工作线程，并返回
        if (workerCountOf(c) != 0) {  Eligible to terminate
            interruptIdleWorkers(ONLY_ONE);
            .mainLock;
        mainLock.lock();
         这里尝试设置状态为TIDYING，如果设置成功，则调用terminated方法
            if (ctl.compareAndSet(c,ctlOf(TIDYING,1)">))) {
                 {
                     terminated方法默认什么都不做，留给子类实现
                    terminated();
                }  设置状态为TERMINATED
                    ctl.set(ctlOf(TERMINATED,1)">));
                    termination.signalAll();
                }
                ;
            }
        }  {
            mainLock.unlock();
        }
         else retry on failed CAS
    }
}

 shutdown() {
     安全策略判断
        checkShutdownAccess();
         切换状态为SHUTDOWN
        advanceRunState(SHUTDOWN);
         中断空闲线程
        interruptIdleWorkers();
        onShutdown();  hook for ScheduledThreadPoolExecutor
    }  尝试结束线程池
    tryTerminate();
}

 interruptIdleWorkers() {
    interruptIdleWorkers();
}
void interruptIdleWorkers( onlyOne) {
     (Worker w : workers) {
            Thread t = w.thread;
            if (!t.isInterrupted() && w.tryLock()) {
                 (SecurityException ignore) {
                }  {
                    w.unlock();
                }
            }
             (onlyOne)
                ;
        }
    }  {
        mainLock.unlock();
    }
}

public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
     {
        checkShutdownAccess();
        advanceRunState(STOP);
         中断所有工作线程，无论是否空闲
        interruptWorkers();
         取出队列中没有被执行的任务
        tasks = drainQueue();
    }  {
        mainLock.unlock();
    }
    tryTerminate();
     tasks;
}