之前對線程池的了解很是主觀，我的了解是線上程池初始化的時候就生成指定的數量的線程，然後将一些任務添加到一個阻塞隊列中，然後多個線程同時從阻塞隊列中取任務執行，當沒有任務時線程阻塞，今天下午看了下大神的部落格以及源碼，發現我自己的了解有些偏頗，是以今天再總結一下。
我們建立線程池時一般都是通過使用Executors.newXXX來建立，是以我們從這個方法入手，無論是建立Fixed還是cached，還是single的線程池，都是調用的同一個方法——ThreadPoolExecutor的構造方法，隻不過是參數不同。
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,//這兩二個參數都是整數，用于限制線程的數量，在後面會用到
0L, TimeUnit.MILLISECONDS,//這兩個參數都是用來指定從阻塞隊列中擷取任務的時候的逾時時間，more on this later。
new LinkedBlockingQueue<Runnable>());//用來儲存任務的阻塞隊列
}
上面的構造方法最終調用的構造方法為：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,//上面這5個已經說過了。
ThreadFactory threadFactory,//這個用來産生thread，預設是 Executors.defaultThreadFactory()這個的傳回值，他負責産生thread，設定thread的name，優先級，設定為daemon，沒有别的作用。
RejectedExecutionHandler handler) {//這個用來處理當過多的任務添加到隊列時，如果隊列無法添加的時候的操作，預設的是AbortPolicy，當發生上述情況時，會抛一個異常。
。。。。//複制操作省略了
}
我們看一下送出任務的方法execute:
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {//如果目前的worker（也即是工作的線程數量）小于corePoolSize，進入if，這裡的corePoolSize也就是我們在構造方法中穿入的第一個參數，很重要，他表示一個線程池隻少要儲存的線程的個數，這些線程是不會過期的，如果阻塞隊列中沒有任務，則會
在阻塞隊列的poll方法中阻塞，而超過這個值的線程在沒有任務的時候就要被回收掉。
if (addWorker(command, true))//添加一個worker，即一個線程，more on this later，
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {//如果上面的沒有return，則進入這個if的判斷，條件是正在運作，且這個任務能添加到隊列中，則進入if
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))//重新檢查，雖然上面應有個isRunning的判斷，但是可能有時間差。進入這個if，如果不是running的話
reject(command);//拒絕這個任務，調用rejectPolicy，預設是抛個異常。
else if (workerCountOf(recheck) == 0)//如果目前的工作線程個數為0，則調用addWorker添加一個工作線程，如果不為0的話，那麼就會有線程不停的從阻塞隊列中獲得任務，是以一定會有線程執行這個任務的。
addWorker(null, false);
}
else if (!addWorker(command, false))//如果添加到隊列中失敗，則判斷是否可以添加工作線程，如果不可以，則拒絕這個任務。
reject(command);
}
經過上面，我們知道了corePoolSize，他是要儲存的最小的工作的線程數（more on this later)，但是還沒有涉及到maximumPoolSize，我們趁熱打鐵看看addWorder方法
private boolean addWorker(Runnable firstTask, boolean core) {//第一個參數表示如果要建立工作線程的話，他要執行的第一個任務，第二個參數是用來做判斷的，如果是true，表示和corePoolSize判斷，false表示和maximumPoolSize判斷。
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&//已經shutdown，不能繼續接受任務。
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);//工作線程的個數
if (wc >= CAPACITY ||//如果現在已經建立的線程的數量太多，
wc >= (core ? corePoolSize : maximumPoolSize))//這裡顯示了core的作用，如果是true，則根據第一個判斷，
return false;//如果建立的worker太多，則傳回false，表示不能繼續建立。
if (compareAndIncrementWorkerCount(c))//使用cas增加c，退出循環，進行建立worker
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
final ReentrantLock mainLock = this.mainLock;
w = new Worker(firstTask);//建立worker
final Thread t = w.thread;
if (t != null) {
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int c = ctl.get();
int rs = runStateOf(c);
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);//将建立的worker添加到集合中
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();//調用建立的worker中的Thread的start方法，
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
下面我們看一下Worker這個類：
Worker(Runnable firstTask) {//這個參數表示當這個worker建立成功後執行的第一個任務。
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;//第一個任務
this.thread = getThreadFactory().newThread(this);//worker中封裝了一個線程，并且這個線程執行的任務是this，因為Worker也是一個runnable，也就是說調用的worker類的run方法
}
同時我們發現Worker也是一個runnable，他的run方法是調用的ThreadPoolExecutor的runWorker方法，也就是當調用worker.thread.start方法的時候是執行的ThreadPoolExecutor的runWorker方法，參數是worker自己，我們看一下
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;//穿入的第一個任務
w.firstTask = null;
w.unlock(); // worker繼承了aqs，實作了lock方法，他的目的是害怕并發執行造成不确定性的後果
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {//或者是第一個任務不為null或者是從隊列中獲得任務不是null，這個getTask方法就是從隊列中獲得任務，比較重要，等會看
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
task.run();//執行擷取的任務，執行這個任務的是worker中封裝的線程。從這裡基本就可以總結出大概了：當線程池添加任務時，會判斷worker的數量，如果過小，就會建立worker，添加到集合，用這個worker執行第一個任務，執行完了再從阻塞隊列中擷取任務。
} 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;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);//這個方法也很重要，它用來處理在所有的任務都處理完成之後的操作。
}
}
看到這裡有兩個方法比較重要，一個是getTask，一個是processWorderExit，
getTask方法：
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
boolean timed; // Are workers subject to culling?
for (;;) {
int wc = workerCountOf(c);
timed = allowCoreThreadTimeOut || wc > corePoolSize;//如果現在工作的線程多于corePoolSize就會是true
if (wc <= maximumPoolSize && ! (timedOut && timed))//剛上來timed是false，跳出第二個for
break;
if (compareAndDecrementWorkerCount(c))
return null;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
try {
Runnable r = timed ?//如果目前的工作線程多餘corePoolSize，則是true
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) ://如果是true，表示有逾時時間的等待。從這裡就能看出corePoolSize的用處了，如果有超過corePoolSize的線程，那麼再從隊列中擷取任務時就會有時間的等待，而且我們之前傳的keepAliveTime是0，也就是說
如果目前隊列中沒有任務的話，超過corePoolSize那些線程就立即傳回，而如果不是超過corePoolSize的線程則會一直等待，
workQueue.take();//沒有逾時時間的等待，會一直阻塞。
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
在這個getTask方法中，我們看到了corePoolSize的重要作用。
processWorderExit方法：
private void processWorkerExit(Worker w, boolean completedAbruptly) {
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
completedTaskCount += w.completedTasks;
workers.remove(w);//這裡可以發現，對于那些在擷取任務時沒有阻塞的線程，在沒有任務後就會被移除集合，也就是被垃圾回收掉。但是對于那些阻塞的就不會被回收掉。
} finally {
mainLock.unlock();
}
。。。。。//下面的沒看。
}
再看一下在Executors中的靜态方法:
1、建立一個fixedThreadPool的話，corePoolSize和maximumPoolSize是一樣的，因為建立的worker的數量不會超過maximumPoolSize,是以worker的數量最多是corePoolSize，即getTask方法中的timed一定是true 是以所有的線程在從阻塞隊列中擷取任務時都是會永遠阻塞的，不會丢掉worker。并且傳入的等待時間是0，是以在從阻塞隊列中獲得任務時不會阻塞，worker直接直接傳回。
2、建立一個cachedThreadPool，
new ThreadPoolExecutor(0, //線程最小的數量是0，即getTask中所有的timed都是false，是以所有的worker在擷取不到任務時都會被抛棄，再有任務時就會建立建立worker
Integer.MAX_VALUE,//最大值超級大，也就是說建立woker的個數幾乎是不受限制的。
60L, TimeUnit.SECONDS,//每個worker在從阻塞隊列中獲得任務時可以阻塞60秒。
new SynchronousQueue<Runnable>() );//一個同步的queue，比較特殊，插入的線程會阻塞直到一個擷取的線程的到來，同樣擷取的線程也會阻塞直到插入的線程到來。
可以看出，cachedThreadPool幾乎可以被認為是不斷建立worker的，worker從阻塞隊列中擷取任務時如果沒有任務時就會阻塞60秒，然後被抛棄。
3、建立一個單線程的線程池：
new ThreadPoolExecutor(1, 1,//核心的數量和最大的數量都是1，也就是永遠是1，
0L, TimeUnit.MILLISECONDS,//阻塞直到有任務
new LinkedBlockingQueue<Runnable>())
很好的糾正了對線程池的了解。
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)