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

private Thread addThread(Runnable firstTask) {
    //構造一個worker任務
    Worker w = new Worker(firstTask);
    //產生一個新線程,把woker封裝進去
    Thread t = threadFactory.newThread(w);
    if (t != null) {
        w.thread = t;
        workers.add(w);
        int nt = ++poolSize;
        if (nt > largestPoolSize)
            largestPoolSize = nt;
    }
    return t;
}

public void run() {
           try {
               Runnable task = firstTask;
               firstTask = null;
               //從阻塞隊列中獲取任務執行
               while (task != null || (task = getTask()) != null) {
                   runTask(task);
                   task = null;
               }
           } finally {
               workerDone(this);
           }
     }

Runnable getTask() {
    for (;;) {
        try {
            int state = runState;
            //線程池不在運行狀態
            if (state > SHUTDOWN)
                return null;
            Runnable r;
            //關閉狀態，把任務poll出
            if (state == SHUTDOWN)  // Help drain queue
                r = workQueue.poll();
            else if (poolSize > corePoolSize || allowCoreThreadTimeOut)
                //超時版本的poll
                r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
            else
                //帶有阻塞的take,如果隊列為空則阻塞
                r = workQueue.take();
            if (r != null)
                return r;
            //如果worker線程能夠退出
            if (workerCanExit()) {
                if (runState >= SHUTDOWN) // Wake up others
                    //清理空閑的worker
                    interruptIdleWorkers();
                return null;
            }
            // Else retry
        } catch (InterruptedException ie) {
            // On interruption, re-check runState
        }
    }
}

private void runTask(Runnable task) {
        final ReentrantLock runLock = this.runLock;
        //加鎖
        runLock.lock();
        try {
            //檢查線程池狀態和線程狀態
            if (runState < STOP &&
                Thread.interrupted() &&
                runState >= STOP)
                thread.interrupt();
            boolean ran = false;
            //執行之前可以插入的操作
            beforeExecute(thread, task);
            try {
                task.run();
                ran = true;
                //執行之后
                afterExecute(task, null);
                ++completedTasks;
            } catch (RuntimeException ex) {
                if (!ran)
                    afterExecute(task, ex);
                throw ex;
            }
        } finally {
            runLock.unlock();
        }
 }

void workerDone(Worker w) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //增加完成的任務計數
        completedTaskCount += w.completedTasks;
        //從worker隊列移出
        workers.remove(w);
        //如果當前的線程數為0，則嘗試停止線程池
        if (--poolSize == 0)
            tryTerminate();
    } finally {
        mainLock.unlock();
    }
}

public void shutdown() { 
    
SecurityManager security = System.getSecurityManager();
//檢查是否有權限
if (security != null)
        security.checkPermission(shutdownPerm);
 
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //再次檢查調用者是否有權限修改線程
        if (security != null) { // Check if caller can modify our threads
            for (Worker w : workers)
                security.checkAccess(w.thread);
        }
        //修改線程池狀態
        int state = runState;
        if (state < SHUTDOWN)
            runState = SHUTDOWN;
 
        try {
            //中斷所有空閑worker線程
            for (Worker w : workers) {
                w.interruptIfIdle();
            }
        } catch (SecurityException se) { // Try to back out
            runState = state;
            // tryTerminate() here would be a no-op
            throw se;
        }
        //關閉線程池
        tryTerminate(); // Terminate now if pool and queue empty
    } finally {
        mainLock.unlock();
    }
}

void interruptIfIdle() {
        final ReentrantLock runLock = this.runLock;
        //嘗試加鎖
        if (runLock.tryLock()) {
            try {
                //如果worker中的線程不是當前調用線程
                if (thread != Thread.currentThread())
                    thread.interrupt();
            } finally {
                runLock.unlock();
            }
        }
}