在使用線程的，我們常使用線程池，線程的複用可以減少線程的開銷，很好的提高cpu資源利用率。這篇文章信息量會很大，做好準備哦~ java源碼系列。
有對線程池沒有直觀感覺的同學可以看看這篇文章。在jdk8中，從ThreadPoolExecutor從發，來逐步講解它的源碼實現。
1.線程池定義初始值
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); private static final int COUNT_BITS = Integer.SIZE - 3; private static final int CAPACITY = (1 << COUNT_BITS) - 1; //容量限制在2^29-1 //線程池中線程有五種狀態 private static final int RUNNING = -1 << COUNT_BITS; //接收新任務並且處理隊列的中任務 private static final int SHUTDOWN = 0 << COUNT_BITS; //不接收新任務，但是處理隊列中的任務 private static final int STOP = 1 << COUNT_BITS; // 不接收新任務，不處理隊列中的任務，中斷正在處理的任務 private static final int TIDYING = 2 << COUNT_BITS; //所有的任務都已經停止了，工作線程的數目爲0，線程在轉換到改狀態是會調用中斷方法 private static final int TERMINATED = 3 << COUNT_BITS; //調用了中斷方法 private static int runStateOf(int c) { return c & ~CAPACITY; } //獲取線程運行的狀態 private static int workerCountOf(int c) { return c & CAPACITY; } //當前工作的線程 private static int ctlOf(int rs, int wc) { return rs | wc; } //獲取ctl
private static boolean runStateAtLeast(int c, int s) { //比較最後的狀態值 return c >= s; } //判斷線程是否正在執行 private static boolean isRunning(int c) { return c < SHUTDOWN; }
初始化了一定基本變量及方法，下面會經常使用到。
2.執行方法
public void execute(Runnable command) { //提交線程的執行方法 if (command == null) //如果放入線程池中的線程爲null，會包空指針異常 throw new NullPointerException(); int c = ctl.get(); //獲取clt的當前值，這個值會經常被修改 if (workerCountOf(c) < corePoolSize) { //工作線程個數小於核心線程個數 if (addWorker(command, true)) //新建一個線程來執行任務 return; c = ctl.get(); //添加線程失敗，重新回去ctl的值，下面isRunning方法需要判斷線程是否是運行狀態 } if (isRunning(c) && workQueue.offer(command)) { //如果線程的個數大於核心線程池的個數,並且當前線程是運行狀態，它就會被放到緩存隊列中 int recheck = ctl.get(); if (! isRunning(recheck) && remove(command)) //如果放到隊列成功了，但是線程池被關了，需要移除掉該線程，沒問題的話就拒絕這個線程的執行 reject(command); else if (workerCountOf(recheck) == 0) //如果工作線程的數量變成0了，添加空的任務，之後其實知道從隊列中取任務時會跳過null的 addWorker(null, false); } else if (!addWorker(command, false)) //隊列滿了，如果小於最大線程池的大小，可以新建線程執行任務，如果大於最大線程池大小，就會拒絕任務 reject(command); }
總結，總有有四步：
第一步，判斷線程是不是爲空，如果是空的話，就拋出空指針異常。
第二步，如果線程的數量小於核心線程池的個數，創建新的線程執行任務。
第三步，如果線程的數量大於核心線程的數量，就將線程放到緩存隊列中。
第四步，緩存隊列的滿了，還沒有到達最大核心線程池的大小，這個時候就也是創建線程執行任務，如果大於最大的核心線程池的大小，那麼就拒絕任務的執行。這裏所說執行任務的線程就是Worker.
2.1添加Woker線程
先來看下Worker的定義
private final class Worker extends AbstractQueuedSynchronizer implements Runnable { private static final long serialVersionUID = 6138294804551838833L; final Thread thread; Runnable firstTask; volatile long completedTasks; Worker(Runnable firstTask) { setState(-1); // inhibit interrupts until runWorker this.firstTask = firstTask; this.thread = getThreadFactory().newThread(this); } /** Delegates main run loop to outer runWorker */ public void run() { runWorker(this); } ....... }繼承了aqs,同時實現了Runable,說明是一個線程.
private boolean addWorker(Runnable firstTask, boolean core) { retry: //retry: 不明白是什麼的可以看這篇文章 for (;;) { int c = ctl.get(); //獲取到最新的ctl int rs = runStateOf(c); //查看當前線程的狀態 //如果線程的狀態是關閉，第一個任務時空，隊列是空，直接返回添加任務失敗 if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())) return false; for (;;) { int wc = workerCountOf(c); if (wc >= CAPACITY || //需要小於容量 wc >= (core ? corePoolSize : maximumPoolSize)) //core爲true，工作線程要小於核心線程數，core爲false,工作線程數要小於最大線程數目。不然，也放回添加任務失敗 return false; if (compareAndIncrementWorkerCount(c)) //如果任務個數添加成功，就跳出循環，這個用到了CAS，不明白的可以看這篇文章 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 { w = new Worker(firstTask); //初始化一個任務 final Thread t = w.thread; if (t != null) { //當前線程不爲空的情況下 final ReentrantLock mainLock = this.mainLock; mainLock.lock(); //獲取鎖 try { int rs = runStateOf(ctl.get()); //需要重新獲取到線程的運行狀態，在獲取鎖之前，他的狀態可能被別的線程改變。 if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { //在線程池是運行狀態，或者線程池被關閉了並且第一個線程是空的情況下 if (t.isAlive()) // 如果線程是活躍狀態，那麼說明先狀態有問題，直接拋出異常 throw new IllegalThreadStateException(); workers.add(w); //將任務加到工作線程集裏面 int s = workers.size(); if (s > largestPoolSize) //largestPoolSize是記錄線程池中出現的最大的線程的數量 largestPoolSize = s; workerAdded = true; } } finally { mainLock.unlock(); //解鎖 } if (workerAdded) { t.start(); //線程啓動，相應的調用run方法 workerStarted = true; } } } finally { if (! workerStarted) //如果工作線程啓動失敗，就將它從工作線程集中移除 addWorkerFailed(w); } return workerStarted; }
總結一下，先校驗線程的狀態，沒有問題就創建一個工作線程，如果線程創建沒有問題就啓動了，如果有問題就將這個工作線程從工作線程集中移除。
3.運行線程
前面已經講過了將線程建立起來，現在需要使線程跑起來了。大家都知道要使線程跑起來，肯定要執行start方法。沒錯，線程池裏面也是這樣乾的。
public void run() { runWorker(this); }
繼續往下看，woker裏面的run方法調用的是線程池裏面的runWorker方法。
final void runWorker(Worker w) { Thread wt = Thread.currentThread(); //取到當前線程 Runnable task = w.firstTask; //拿到第一個工作線程的第一個線程 w.firstTask = null; w.unlock(); // 允許出現多箇中斷 boolean completedAbruptly = true; try { 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 { 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; //將任務置成null w.completedTasks++; //完成的任務加一 w.unlock(); } } completedAbruptly = false; //是否完全結束，false表示 完全結束了 } finally { processWorkerExit(w, completedAbruptly); //清除任務 } }
總結：不斷的取任務執行，如果執行完成了記錄任務的執行數加一，將這個線程從工作任務（工作線程）集中刪除。
進一步查看是怎麼獲取任務的getTask（）
private Runnable getTask() { boolean timedOut = false; for (;;) { int c = ctl.get(); int rs = runStateOf(c); // 如果線程池關了，返回的任務時null if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) { decrementWorkerCount(); return null; } int wc = workerCountOf(c); // 是否允許核心線程數超時，當滿足allowCoreThreadTimeOut被設置爲true 或當前線程數大於核心線程數時，timed=true boolean timed = allowCoreThreadTimeOut || wc > corePoolSize; if ((wc > maximumPoolSize || (timed && timedOut)) //超過最大線程數或超時或任務隊列爲空 && (wc > 1 || workQueue.isEmpty())) { if (compareAndDecrementWorkerCount(c)) //如果線程數減到了-1 ，就返回null return null; continue; //跳過下面的任務執行 } try { Runnable r = timed ? //設置了超時，按超時的，沒有超時的話，就直接從隊列的拿出任務來執行 workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); if (r != null) return r; timedOut = true; } catch (InterruptedException retry) { timedOut = false; } } }
到此差不多已經基本上講完了線程池的運行流程，還有一個添加進工作隊列的方法沒有講，涉及到了LinkedBlockQueue,已經專門寫了一篇文章來講解。
其實講了這麼多，大家只要知道線程池的使用和運行流程就可以了。它的使用demo在此就不在講解了，網上也有很多例子。再來溫習一下它的運行流程。
第一步，判斷線程是不是爲空，如果是空的話，就拋出空指針異常。
第二步，如果線程的數量小於核心線程池的個數，創建新的線程執行任務。
第三步，如果線程的數量大於核心線程的數量，就將線程放到緩存隊列中。
第四步，緩存隊列的滿了，還沒有到達最大核心線程池的大小，這個時候就也是創建線程執行任務，如果大於最大的核心線程池的大小，那麼就拒絕任務的執行。這裏所說執行任務的線程就是Worker.
當然如果設置了超時，在時間範圍內，任務肯定是可以被執行的，超時返回的就是一個空的任務，不會執行之前的任務。有一個地方需要注意的是：只有在線程數大於核心線程數的時候，任務纔會被放到任務隊列裏面，小於的話，任務時直接執行的。
