RUNNING    -- 对应的高3位值是111。
SHUTDOWN   -- 对应的高3位值是000。
STOP       -- 对应的高3位值是001。
TIDYING    -- 对应的高3位值是010。
TERMINATED -- 对应的高3位值是011。

 1 public void execute(Runnable command) {
 2         if (command == null)
 3             throw new NullPointerException();
 4         /*
 5          * Proceed in 3 steps:
 6          *
 7          * 1. If fewer than corePoolSize threads are running, try to
 8          * start a new thread with the given command as its first
 9          * task.  The call to addWorker atomically checks runState and
10          * workerCount, and so prevents false alarms that would add
11          * threads when it shouldn't, by returning false.
12          *
13          * 2. If a task can be successfully queued, then we still need
14          * to double-check whether we should have added a thread
15          * (because existing ones died since last checking) or that
16          * the pool shut down since entry into this method. So we
17          * recheck state and if necessary roll back the enqueuing if
18          * stopped, or start a new thread if there are none.
19          *
20          * 3. If we cannot queue task, then we try to add a new
21          * thread.  If it fails, we know we are shut down or saturated
22          * and so reject the task.
23          */
24         int c = ctl.get();
25         if (workerCountOf(c) < corePoolSize) {
26             if (addWorker(command, true))
27                 return;
28             c = ctl.get();
29         }
30         if (isRunning(c) && workQueue.offer(command)) {
31             int recheck = ctl.get();
32             if (! isRunning(recheck) && remove(command))
33                 reject(command);
34             else if (workerCountOf(recheck) == 0)
35                 addWorker(null, false);
36         }
37         else if (!addWorker(command, false))
38             reject(command);
39     }

 1 private boolean addWorker(Runnable firstTask, boolean core) {
 2         retry: // 标记，表示跳出循环时，从哪里开始执行，类似于goto
 3         for (;;) {
 4             int c = ctl.get(); // 获取ctl对应的值，“生效线程数”和“线程池状态”
 5             int rs = runStateOf(c); // 获取线程池状态
 6
 7             // Check if queue empty only if necessary.
 8             // 如果该if判断想要返回false，队列为空为必要条件，因为addWorker()不只是在接收新任务会调用到，处理队列的任务也会调用到。在线程池状态为SHUTDOWN时还会处理队列中的任务，所以队列不为空会继续向下执行
 9             if (rs >= SHUTDOWN &&
10                 ! (rs == SHUTDOWN &&
11                    firstTask == null &&
12                    ! workQueue.isEmpty()))
13                 return false;
14             /* 内循环意义：判断worker是否符合corePoolSize和maximumPoolSize定义，不满足则返回false；                  然后利用CAS自增workerCount，如果CAS成功则退出循环；                  如果CAS失败会继续自旋，在自旋过程中会检查线程池状态，如果发生变化，则回退到外层循环，重新执行。
15                因此内循环的主要作用就是让workerCount在符合条件下自增。
16             */
17             for (;;) {
18                 int wc = workerCountOf(c);
19                 if (wc >= CAPACITY ||
20                     wc >= (core ? corePoolSize : maximumPoolSize))
21                     return false;
22                 if (compareAndIncrementWorkerCount(c))
23                     break retry;
24                 c = ctl.get();  // Re-read ctl
25                 if (runStateOf(c) != rs)
26                     continue retry;
27                 // else CAS failed due to workerCount change; retry inner loop
28             }
29         }
30
31         boolean workerStarted = false;
32         boolean workerAdded = false;
33         Worker w = null;
34         // 这段代码的主要功能：添加任务到线程池，并启动任务所在的线程
35         try {
36             // 创建一个Worker对象，包含一个由线程工厂创建的线程和一个需执行的任务
37             w = new Worker(firstTask);
38             final Thread t = w.thread;
39             if (t != null) {
40                 // 线程创建成功 获取一个可重入锁，把Worker对象放入worker成员变量中
41                 final ReentrantLock mainLock = this.mainLock;
42                 mainLock.lock();
43                 try {
44                     // Recheck while holding lock.
45                     // Back out on ThreadFactory failure or if
46                     // shut down before lock acquired.
47                     int rs = runStateOf(ctl.get());
48                     // 检查线程池状态和线程状态
49                     if (rs < SHUTDOWN ||
50                         (rs == SHUTDOWN && firstTask == null)) {
51                         if (t.isAlive()) // precheck that t is startable
52                             throw new IllegalThreadStateException();
53                         workers.add(w); // 将Worker变量加入workers中（集合）
54                         // 更新largestPoolSize
55                         int s = workers.size();
56                         if (s > largestPoolSize)
57                             largestPoolSize = s;
58                         workerAdded = true;
59                     }
60                 } finally {
61                     mainLock.unlock();
62                 }
63                 // 如果任务添加成功，则启动任务所在的线程
64                 if (workerAdded) {
65                     t.start();
66                     workerStarted = true;
67                 }
68             }
69         } finally {
70             // 如果任务添加失败则执行addWorkerFailed进行回滚
71             if (! workerStarted)
72                 addWorkerFailed(w);
73         }
74         return workerStarted;
75     }

 1   private void addWorkerFailed(Worker w) {
 2         final ReentrantLock mainLock = this.mainLock;
 3         // 加锁回滚
 4         mainLock.lock();
 5         try {
 6             if (w != null)
 7                 workers.remove(w); // 回滚workers
 8             decrementWorkerCount();// 回滚workerCount
 9             tryTerminate();// 判断线程池状态，是否需要终结线程池
10         } finally {
11             mainLock.unlock();
12         }
13     }