提綱
是什么（使用線程池的原因，線程池的定義，好處，線程池原理）
怎么用（常見的使用方式，以及各個參數(shù)的作用）
為什么（源碼分析，設(shè)計模式分析）
關(guān)于原理在android中的部分應(yīng)用，部分注意事項
引子（原因）
多線程技術(shù)：
多線程技術(shù)主要解決處理器單元內(nèi)多個線程執(zhí)行的問題，它可以顯著減少處理器單元的閑置時間，增加處理器單元的吞吐能力
多線程的異步執(zhí)行方式，雖然能夠最大限度發(fā)揮多核計算機的計算能力，但是如果不加控制，反而會對系統(tǒng)造成負擔。線程本身也要占用內(nèi)存空間，大量的線程會占用內(nèi)存資源并且可能會導(dǎo)致Out of Memory。即便沒有這樣的情況，大量的線程回收也會給GC帶來很大的壓力。
當創(chuàng)建線程時間+銷毀線程時間遠大于在線程中執(zhí)行任務(wù)的時間時 或者 需要多次調(diào)用多線程異步任務(wù)時，我們可以考慮線程池
什么是線程池
定義
一種線程使用模式，通過池化技術(shù)維護著多個線程，對線程進行統(tǒng)一管理和復(fù)用，避免了在處理短時間任務(wù)時創(chuàng)建與銷毀線程的代價。線程池不僅能夠保證內(nèi)核的充分利用，還能防止過分調(diào)度。
原理
池化技術(shù)，享元模式，對線程進行統(tǒng)一管理和復(fù)用
使用線程池的好處
減少了創(chuàng)建和銷毀線程的次數(shù)，每個工作線程都可以被重復(fù)利用，可執(zhí)行多個任務(wù)。從而減少線程的創(chuàng)建和銷毀，節(jié)約系統(tǒng)的開銷
對線程具有統(tǒng)一的管理，可以根據(jù)系統(tǒng)的承受能力，調(diào)整線程池中工作線線程的數(shù)目，防止因為消耗過多的內(nèi)存
簡單的demo對比結(jié)果
怎么使用線程池
使用線程池主要涉及兩個類
ExecutorService：線程池接口，提供了眾多接口api來控制線程池中的線程
ThreadPoolExecutor：實現(xiàn)了ExecutorService接口，并封裝了一系列的api使得它具有線程池的特性，其中包括工作隊列、核心線程數(shù)、最大線程數(shù)等，可以說這個就是線程池的代表類
要創(chuàng)建一個線程池只需要new ThreadPoolExecutor(…);就可以創(chuàng)建一個線程池，而如果這樣創(chuàng)建線程池的話，我們需要配置一堆東西，非常麻煩，我們可以看一下它的構(gòu)造方法就知道了：
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler) {...}
所以，官方也不推薦使用這種方法來創(chuàng)建線程池，而是推薦使用Executors的工廠方法來創(chuàng)建線程池，Executors類是官方提供的一個工廠類，它里面封裝好了眾多功能不一樣的線程池，從而使得我們創(chuàng)建線程池非常的簡便，主要提供了如下五種功能不一樣的線程池：
1、newFixedThreadPool() ：
作用：該方法返回一個固定線程數(shù)量的線程池，該線程池中的線程數(shù)量始終不變，即不會再創(chuàng)建新的線程，也不會銷毀已經(jīng)創(chuàng)建好的線程，自始自終都是那幾個固定的線程在工作，所以該線程池可以控制線程的最大并發(fā)數(shù)。
栗子：假如有一個新任務(wù)提交時，線程池中如果有空閑的線程則立即使用空閑線程來處理任務(wù)，如果沒有，則會把這個新任務(wù)存在一個任務(wù)隊列中，一旦有線程空閑了，則按FIFO方式處理任務(wù)隊列中的任務(wù)。
2、newCachedThreadPool() ：
作用：該方法返回一個可以根據(jù)實際情況調(diào)整線程池中線程的數(shù)量的線程池。即該線程池中的線程數(shù)量不確定，是根據(jù)實際情況動態(tài)調(diào)整的。
栗子：假如該線程池中的所有線程都正在工作，而此時有新任務(wù)提交，那么將會創(chuàng)建新的線程去處理該任務(wù)，而此時假如之前有一些線程完成了任務(wù)，現(xiàn)在又有新任務(wù)提交，那么將不會創(chuàng)建新線程去處理，而是復(fù)用空閑的線程去處理新任務(wù)。那么此時有人有疑問了，那這樣來說該線程池的線程豈不是會越集越多？其實并不會，因為線程池中的線程都有一個“保持活動時間”的參數(shù)，通過配置它，如果線程池中的空閑線程的空閑時間超過該“保存活動時間”則立刻停止該線程，而該線程池默認的“保持活動時間”為60s。
3、newSingleThreadExecutor() ：
作用：該方法返回一個只有一個線程的線程池，即每次只能執(zhí)行一個線程任務(wù)，多余的任務(wù)會保存到一個任務(wù)隊列中，等待這一個線程空閑，當這個線程空閑了再按FIFO方式順序執(zhí)行任務(wù)隊列中的任務(wù)。
4、newScheduledThreadPool() ：
作用：該方法返回一個可以控制線程池內(nèi)線程定時或周期性執(zhí)行某任務(wù)的線程池。
5、newSingleThreadScheduledExecutor() ：
作用：該方法返回一個可以控制線程池內(nèi)線程定時或周期性執(zhí)行某任務(wù)的線程池。只不過和上面的區(qū)別是該線程池大小為1，而上面的可以指定線程池的大小。
獲取這五種線程池
通過Executors的工廠方法來獲?。?/p>
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5); ? ?
ExecutorService singleThreadPool = Executors.newSingleThreadExecutor(); ? ?
ExecutorService cachedThreadPool = Executors.newCachedThreadPool(); ? ?
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5); ?
ScheduledExecutorService singleThreadScheduledPool = Executors.newSingleThreadScheduledExecutor();
我們可以看到通過Executors的工廠方法來創(chuàng)建線程池極其簡便，其實它的內(nèi)部還是通過new ThreadPoolExecutor(…)的方式創(chuàng)建線程池的，我們看一下這些工廠方法的內(nèi)部實現(xiàn)：
public static ExecutorService newFixedThreadPool(int nThreads) { ? ? ? ?
return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue()); ? ? } ??
? public static ExecutorService newSingleThreadExecutor() {? ?
??return new FinalizableDelegatedExecutorService （new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue())); ?? }?
public static ExecutorService newCachedThreadPool() {? ? ?
return new ThreadPoolExecutor(0, Integer.MAX_VALUE, ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?? ? ? 60L, TimeUnit.SECONDS,new SynchronousQueue()); ? ? }
我們可以清楚的看到這些方法的內(nèi)部實現(xiàn)都是通過創(chuàng)建一個ThreadPoolExecutor對象來創(chuàng)建的，正所謂萬變不離其宗，所以我們要了解線程池還是得了解ThreadPoolExecutor這個線程池類
了解ThreadPoolExecutor
所以我們主要就是要了解ThreadPoolExecutor，從構(gòu)造方法開始：
我們可以看到它構(gòu)造方法的參數(shù)比較多，有七個，下面一一來說明這些參數(shù)的作用：
corePoolSize：線程池中的核心線程數(shù)量
maximumPoolSize：線程池中的最大線程數(shù)量
keepAliveTime：這個就是上面說到的“保持活動時間“，上面只是大概說明了一下它的作用，不過它起作用必須在一個前提下，就是當線程池中的線程數(shù)量超過了corePoolSize時，它表示多余的空閑線程的存活時間，即：多余的空閑線程在超過keepAliveTime時間內(nèi)沒有任務(wù)的話則被銷毀。而這個主要應(yīng)用在緩存線程池中
unit：它是一個枚舉類型，表示keepAliveTime的單位，常用的如：TimeUnit.SECONDS（秒）、TimeUnit.MILLISECONDS（毫秒）
workQueue：任務(wù)隊列，主要用來存儲已經(jīng)提交但未被執(zhí)行的任務(wù)，不同的線程池采用的排隊策略不一樣
threadFactory：線程工廠，用來創(chuàng)建線程池中的線程，通常用默認的即可
handler：通常叫做拒絕策略，1、在線程池已經(jīng)關(guān)閉的情況下 2、任務(wù)太多導(dǎo)致最大線程數(shù)和任務(wù)隊列已經(jīng)飽和，無法再接收新的任務(wù) 。在上面兩種情況下，只要滿足其中一種時，在使用execute()來提交新的任務(wù)時將會拒絕，而默認的拒絕策略是拋一個RejectedExecutionException異常
workQueue這個任務(wù)隊列卻要再次說明一下，它是一個BlockingQueue<Runnable>對象，而泛型則限定它是用來存放Runnable對象的，剛剛上面講了，不同的線程池它的任務(wù)隊列實現(xiàn)肯定是不一樣的，所以，保證不同線程池有著不同的功能的核心就是這個workQueue的實現(xiàn)了，細心的會發(fā)現(xiàn)在剛剛的用來創(chuàng)建線程池的工廠方法中，針對不同的線程池傳入的workQueue也不一樣，下面我總結(jié)一下這五種線程池分別用的是什么BlockingQueue：
1、newFixedThreadPool()—>LinkedBlockingQueue
2、newSingleThreadExecutor()—>LinkedBlockingQueue
3、newCachedThreadPool()—>SynchronousQueue
4、newScheduledThreadPool()—>DelayedWorkQueue
5、newSingleThreadScheduledExecutor()—>DelayedWorkQueue
這些隊列分別表示：
LinkedBlockingQueue：無界的隊列
SynchronousQueue：直接提交的隊列
DelayedWorkQueue：等待隊列
當然實現(xiàn)了BlockingQueue接口的隊列還有：ArrayBlockingQueue（有界的隊列）、PriorityBlockingQueue（優(yōu)先級隊列）。這些隊列的詳細作用就不多介紹了。
當 Executor 已經(jīng)關(guān)閉，并且 Executor 將有限邊界用于最大線程和工作隊列容量，且已經(jīng)飽和時，在方法execute(java.lang.Runnable) 中提交的新任務(wù)將被拒絕。在以上兩種情況下，execute 方法都將調(diào)用其RejectedExecutionHandler 的 RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四種預(yù)定義的處理程序策略：
A. 在默認的 ThreadPoolExecutor.AbortPolicy 中，處理程序遭到拒絕將拋出運行時 RejectedExecutionException。
B. 在 ThreadPoolExecutor.CallerRunsPolicy 中，線程調(diào)用運行該任務(wù)的 execute 本身。此策略提供簡單的反饋控制機制，能夠減緩新任務(wù)的提交速度。
C. 在 ThreadPoolExecutor.DiscardPolicy 中，不能執(zhí)行的任務(wù)將被刪除。
D. 在 ThreadPoolExecutor.DiscardOldestPolicy 中，如果執(zhí)行程序尚未關(guān)閉，則位于工作隊列頭部的任務(wù)將被刪除，然后重試執(zhí)行程序（如果再次失敗，則重復(fù)此過程）。
LinkedBlockingQueue
1:如果未指定容量，默認容量為Integer.MAX_VALUE ，容量范圍可以在構(gòu)造方法參數(shù)中指定作為防止隊列過度擴展。
2:此對象是 線程阻塞-安全的
3：不接受 null 元素
4:它實現(xiàn)了BlockingQueue接口。
5:實現(xiàn)了 Collection 和 Iterator 接口的所有可選 方法。
線程池ThreadPoolExecutor的使用
使用線程池，其中涉及到一個極其重要的方法，即：
execute(Runnable command)
該方法意為執(zhí)行給定的任務(wù)，該任務(wù)處理可能在新的線程、已入池的線程或者正調(diào)用的線程，這由ThreadPoolExecutor的實現(xiàn)決定。
當一個任務(wù)通過execute(Runnable)方法欲添加到線程池時：
l 如果此時線程池中的數(shù)量小于corePoolSize，即使線程池中的線程都處于空閑狀態(tài)，也要創(chuàng)建新的線程來處理被添加的任務(wù)。
l 如果此時線程池中的數(shù)量等于 corePoolSize，但是緩沖隊列 workQueue未滿，那么任務(wù)被放入緩沖隊列。
l 如果此時線程池中的數(shù)量大于corePoolSize，緩沖隊列workQueue滿，并且線程池中的數(shù)量小于maximumPoolSize，建新的線程來處理被添加的任務(wù)。
l 如果此時線程池中的數(shù)量大于corePoolSize，緩沖隊列workQueue滿，并且線程池中的數(shù)量等于maximumPoolSize，那么通過 handler所指定的策略來處理此任務(wù)。也就是：處理任務(wù)的優(yōu)先級為：核心線程corePoolSize、任務(wù)隊列workQueue、最大線程maximumPoolSize，如果三者都滿了，使用handler處理被拒絕的任務(wù)。
l 當線程池中的線程數(shù)量大于 corePoolSize時，如果某線程空閑時間超過keepAliveTime，線程將被終止。這樣，線程池可以動態(tài)的調(diào)整池中的線程數(shù)。
優(yōu)先級線程池的優(yōu)點
優(yōu)先級可以在線程實現(xiàn)了BlockingQueue接口的隊列還有：ArrayBlockingQueue（有界的隊列）、PriorityBlockingQueue（優(yōu)先級隊列）。這些隊列的詳細作用就不多介紹了。池中線程數(shù)量不足或系統(tǒng)資源緊張時，優(yōu)先處理我們想要先處理的任務(wù)，而優(yōu)先級低的則放到后面再處理，這極大改善了系統(tǒng)默認線程池以FIFO方式處理任務(wù)的不靈活
擴展線程池ThreadPoolExecutor
除了內(nèi)置的功能外，ThreadPoolExecutor也向外提供了三個接口供我們自己擴展?jié)M足我們需求的線程池，這三個接口分別是：
beforeExecute() - 任務(wù)執(zhí)行前執(zhí)行的方法
afterExecute() -任務(wù)執(zhí)行結(jié)束后執(zhí)行的方法
terminated() -線程池關(guān)閉后執(zhí)行的方法
這三個方法在ThreadPoolExecutor內(nèi)部都沒有實現(xiàn)
前面兩個方法我們可以在ThreadPoolExecutor內(nèi)部的runWorker()方法中找到，而runWorker()是ThreadPoolExecutor的內(nèi)部類Worker實現(xiàn)的方法，Worker它實現(xiàn)了Runnable接口，也正是線程池內(nèi)處理任務(wù)的工作線程，而Worker.runWorker()方法則是處理我們所提交的任務(wù)的方法，它會同時被多個線程訪問，所以我們看runWorker()方法的實現(xiàn)，由于涉及到多個線程的異步調(diào)用，必然是需要使用鎖來處理，而這里使用的是Lock來實現(xiàn)的，我們來看看runWorker()方法內(nèi)主要實現(xiàn)：
可以看到在task.run()之前和之后分別調(diào)用了beforeExecute和afterExecute方法，并傳入了我們的任務(wù)Runnable對象
而terminated()則是在關(guān)閉線程池的方法中調(diào)用，而關(guān)閉線程池有兩個方法，我貼其中一個：
優(yōu)化線程池ThreadPoolExecutor
雖說線程池極大改善了系統(tǒng)的性能，不過創(chuàng)建線程池也是需要資源的，所以線程池內(nèi)線程數(shù)量的大小也會影響系統(tǒng)的性能，大了反而浪費資源，小了反而影響系統(tǒng)的吞吐量，所以我們創(chuàng)建線程池需要把握一個度才能合理的發(fā)揮它的優(yōu)點，通常來說我們要考慮的因素有CPU的數(shù)量、內(nèi)存的大小、并發(fā)請求的數(shù)量等因素，按需調(diào)整。
通常核心線程數(shù)可以設(shè)為CPU數(shù)量+1，而最大線程數(shù)可以設(shè)為CPU的數(shù)量*2+1。
獲取CPU數(shù)量的方法為：
Runtime.getRuntime().availableProcessors();
java線程池大小為何會大多被設(shè)置成CPU核心數(shù)+1？https://blog.csdn.net/varyall/article/details/79583036
線程池大小設(shè)置，CPU的核心數(shù)、線程數(shù)的關(guān)系和區(qū)別，同步與堵塞完全是兩碼事https://blog.csdn.net/tbdp6411/article/details/78443732
最佳線程數(shù)目 = （線程等待時間與線程CPU時間之比 + 1）* CPU數(shù)目
從任務(wù)的優(yōu)先級，任務(wù)的執(zhí)行時間長短，任務(wù)的性質(zhì)（CPU密集/ IO密集），任務(wù)的依賴關(guān)系這四個角度來分析。并且近可能地使用有界的工作隊列。
性質(zhì)不同的任務(wù)可用使用不同規(guī)模的線程池分開處理：
CPU密集型：盡可能少的線程，Ncpu+1
IO密集型：盡可能多的線程, Ncpu*2，比如數(shù)據(jù)庫連接池
混合型：CPU密集型的任務(wù)與IO密集型任務(wù)的執(zhí)行時間差別較小，拆分為兩個線程池；否則沒有必要拆分。
shutdown()和shutdownNow()的區(qū)別
關(guān)于線程池的停止，ExecutorService為我們提供了兩個方法：shutdown和shutdownNow，這兩個方法各有不同，可以根據(jù)實際需求方便的運用，如下：
1、shutdown()方法在終止前允許執(zhí)行以前提交的任務(wù)。
?2、shutdownNow()方法則是阻止正在任務(wù)隊列中等待任務(wù)的啟動并試圖停止當前正在執(zhí)行的任務(wù)。
遍歷線程池中的所有線程，然后逐個調(diào)用線程的interrupt方法來中斷線程.
shutdown 將線程池里的線程狀態(tài)設(shè)置成SHUTDOWN狀態(tài), 然后中斷所有沒有正在執(zhí)行任務(wù)的線程. shutdownNow 將線程池里的線程狀態(tài)設(shè)置成STOP狀態(tài), 然后停止所有正在執(zhí)行或暫停任務(wù)的線程. 只要調(diào)用這兩個關(guān)閉方法中的任意一個, isShutDown() 返回true. 當所有任務(wù)都成功關(guān)閉了, isTerminated()返回true.
線程池源碼分析原理
之前說到線程池原理是對多個線程的管理復(fù)用，減少了線程的創(chuàng)建和銷毀過程，也減少了創(chuàng)建線程的數(shù)目，從而提高了效率。也講到各個參數(shù)的作用，接下來我們看看線程池的源碼是怎么實現(xiàn)這些操作的。
其中AtomicInteger變量ctl的功能非常強大：利用低29位表示線程池中線程數(shù)，通過高3位表示線程池的運行狀態(tài)：
1、RUNNING：-1 << COUNT_BITS，即高3位為111，該狀態(tài)的線程池會接收新任務(wù)，并處理阻塞隊列中的任務(wù)；?
2、SHUTDOWN： 0 << COUNT_BITS，即高3位為000，該狀態(tài)的線程池不會接收新任務(wù)，但會處理阻塞隊列中的任務(wù)；?
3、STOP ： 1 << COUNT_BITS，即高3位為001，該狀態(tài)的線程不會接收新任務(wù)，也不會處理阻塞隊列中的任務(wù)，而且會中斷正在運行的任務(wù)；?
4、TIDYING ： 2 << COUNT_BITS，即高3位為010, 所有的任務(wù)都已經(jīng)終止
5、TERMINATED： 3 << COUNT_BITS，即高3位為011, terminated()方法已經(jīng)執(zhí)行完成
1、先看一下線程池的executor方法（任務(wù)入口）
判斷當前活躍線程數(shù)是否小于corePoolSize,如果小于，則調(diào)用addWorker創(chuàng)建線程執(zhí)行任務(wù)
如果不小于corePoolSize，則將任務(wù)添加到workQueue隊列。
如果放入workQueue失敗，則創(chuàng)建線程執(zhí)行任務(wù)，如果這時創(chuàng)建線程失敗(當前線程數(shù)不小于maximumPoolSize時)，就會調(diào)用reject(內(nèi)部調(diào)用handler)拒絕接受任務(wù)。
為什么需要double check線程池的狀態(tài)？
在多線程環(huán)境下，線程池的狀態(tài)時刻在變化，而ctl.get()是非原子操作，很有可能剛獲取了線程池狀態(tài)后線程池狀態(tài)就改變了。判斷是否將command加入workque是線程池之前的狀態(tài)。倘若沒有double check，萬一線程池處于非running狀態(tài)（在多線程環(huán)境下很有可能發(fā)生），那么command永遠不會執(zhí)行。
2、再看下addWorker的方法實現(xiàn)
3、再到Worker里看看其實現(xiàn)
4、接下來咱們看看runWorker方法的邏輯
5、最后在看看getTask方法實現(xiàn)
參考：Java線程池實現(xiàn)原理與源碼解析(jdk1.8)https://blog.csdn.net/programmer_at/article/details/79799267#4-threadpoolexecutor%E6%BA%90%E7%A0%81
關(guān)于原理在android中的部分應(yīng)用
關(guān)于AsyncTask的實現(xiàn)
大家都知道AsyncTask內(nèi)部實現(xiàn)其實就是Thread+Handler。其中Handler是為了處理線程之間的通信，而這個Thread到底是指什么呢？通過AsyncTask源碼可以得知，其實這個Thread是線程池，AsyncTask內(nèi)部實現(xiàn)了兩個線程池，分別是：串行線程池和固定線程數(shù)量的線程池。而這個固定線程數(shù)量則是通過CPU的數(shù)量決定的。
在默認情況下，我們大都通過AsyncTask::execute()來執(zhí)行任務(wù)的， ，而execute()內(nèi)部則是調(diào)用executeOnExecutor(sDefaultExecutor, params)方法執(zhí)行的，第一個參數(shù)就是指定處理該任務(wù)的線程池，而默認情況下AsyncTask是傳入串行線程池（在這里不講版本的變化），也就是任務(wù)只能單個的按順序執(zhí)行，而我們要是想讓AsyncTask并行的處理任務(wù)，大家都知道調(diào)用AsyncTask::executeOnExecutor(sDefaultExecutor, params)方法傳入這個參數(shù)即可：AsyncTask.THREAD_POOL_EXECUTOR。 而這個參數(shù)的意義在于為任務(wù)指定了一個固定線程數(shù)量的線程池去處理，從而達到了并行處理的功能，我們可以在源碼中看到AsyncTask.THREAD_POOL_EXECUTOR這個參數(shù)就是一個固定線程數(shù)量的線程池：
關(guān)于message的實現(xiàn)
我們都知道m(xù)essage也有關(guān)于obtain的實現(xiàn) ，通過obtain獲取message對象來使用代替new一個也是google推薦的做法， 這里也有用到享元模式，通過復(fù)用已有的message對象來減少創(chuàng)建及回收。
message內(nèi)部有個靜態(tài)的消息池，采用的是鏈表的實現(xiàn)方式進行管理，最大數(shù)量為50，當調(diào)用obtain方法時，會先上鎖，判斷當前的節(jié)點是否為空，不為空則使用并將當前節(jié)點指向下一個，并減少poolsize。
對應(yīng)的，在釋放的時候，message為recycle中會上鎖后添加設(shè)置節(jié)點，增加poolsize，從而達成message的復(fù)用
關(guān)于對象池
在平時的邏輯中，如果我們想實現(xiàn)相關(guān)的享元復(fù)用，可以有多種方式，只要形成相應(yīng)管理，用棧，隊列，列表，數(shù)組，鏈表等結(jié)構(gòu)進行管理，提供獲取和回收方法。就可以達到相應(yīng)目的。
實際上，在android的android.support.v4.util包中，就有提供Pools類來幫助我們事先緩存對象。提供了SimplePool、SynchronizedPool來創(chuàng)建對象池
在android.support.v4.util包下的Pools類中，分別聲明了Pool接口，SimplePool實現(xiàn)類與SynchronizedPool實現(xiàn)類，其中具體的UML關(guān)系如下圖所示：
其內(nèi)部代碼也比較簡單，面向開發(fā)者提供了泛型的對象池，基于數(shù)組實現(xiàn)，其中對象池的最大容量是通過用戶手動設(shè)定。從對象池中獲取數(shù)據(jù)是通過acquire方法?；厥债斍皩ο蟮綄ο蟪刂惺峭ㄟ^release方法。
關(guān)于acquire方法
在acquire方法中，會從對象池中取出對象。具體列子如下圖所示：
acquire()方法總會取當前對象池中存儲的最后一個數(shù)據(jù)。如果有則返回。同時將該位置置為null。反之返回為null。
關(guān)于release方法
在release方法中，會將對象緩存到對象池中。如果當前對象已經(jīng)存在，會拋出異常。反之則存儲。具體列子如下圖所示：
release( T instance)方法，總會將需要回收的對象存入當前對象池中存儲的最后一個數(shù)據(jù)的下一個位置。如果當前回收的對象已經(jīng)存在會拋出異常。反之則成功。
同步對象池（SynchronizedPool）
SynchronizedPool的代碼理解起來也同樣非常簡單，直接繼承SimplePool。并重寫了SimplePool的兩個方法。并為其加上了鎖，保證了多線程情況下使用的安全性。
Synchronized是通過對象內(nèi)部的一個叫做監(jiān)視器鎖（monitor）來實現(xiàn)的。但是監(jiān)視器鎖本質(zhì)又是依賴于底層的操作系統(tǒng)的Mutex Lock來實現(xiàn)的。而操作系統(tǒng)實現(xiàn)線程之間的切換這就需要從用戶態(tài)轉(zhuǎn)換到內(nèi)核態(tài)，這個成本非常高，狀態(tài)之間的轉(zhuǎn)換需要相對比較長的時間，這就是為什么Synchronized效率低的原因。
因此，這種依賴于操作系統(tǒng)Mutex Lock所實現(xiàn)的鎖我們稱之為“重量級鎖”。JDK中對Synchronized做的種種優(yōu)化，其核心都是為了減少這種重量級鎖的使用。JDK1.6以后，為了減少獲得鎖和釋放鎖所帶來的性能消耗，提高性能，引入了“偏向鎖”和“輕量級鎖”。無鎖 --> 偏向鎖 --> 輕量級 --> 重量級
鎖的方面有太多知識，這里不會鋪開講，有興趣可以研究下做分享
讓你徹底理解Synchronizedhttp://www.itdecent.cn/p/d53bf830fa09
分門別類總結(jié)Java中的各種鎖https://blog.csdn.net/renwei289443/article/details/79540809
JAVA鎖有哪些種類https://blog.csdn.net/nalanmingdian/article/details/77800355
簡單了解鎖機制
概念：
鎖(lock)或互斥(mutex)是一種同步機制，用于在有許多執(zhí)行線程的環(huán)境中強制對資源的訪問限制。鎖旨在強制實施互斥排他、并發(fā)控制策略
Java線程阻塞：java的線程是映射到操作系統(tǒng)原生線程之上的，如果要阻塞或喚醒一個線程就需要操作系統(tǒng)介入，需要在戶態(tài)與核心態(tài)之間切換，這種切換會消耗大量的系統(tǒng)資源
?內(nèi)核態(tài):?CPU可以訪問內(nèi)存所有數(shù)據(jù), 包括外圍設(shè)備, 例如硬盤, 網(wǎng)卡. CPU也可以將自己從一個程序切換到另一個程序
?用戶態(tài):?只能受限的訪問內(nèi)存, 且不允許訪問外圍設(shè)備. 占用CPU的能力被剝奪, CPU資源可以被其他程序獲取
Java鎖的實現(xiàn)：
markword是java對象數(shù)據(jù)結(jié)構(gòu)中的一部分，用于存儲對象自身的運行時數(shù)據(jù)，如哈希碼（HashCode）、GC分代年齡、鎖狀態(tài)標志、線程持有的鎖、偏向線程ID、偏向時間戳等，其最后2bit是鎖狀態(tài)標志位，表示不同級別的鎖
對鎖的不同效率進行的分類（無鎖 --> 偏向鎖 --> 輕量級 --> 重量級）?
偏向鎖：指一段同步代碼一直被一個線程所訪問，那么該線程會自動獲取鎖。降低獲取鎖的代價。?
輕量級鎖：指當鎖是偏向鎖的時候，被另一個線程所訪問，偏向鎖就會升級為輕量級鎖，其他線程會通過自旋的形式嘗試獲取鎖，不會阻塞，提高性能。
?重量級鎖： 指當鎖為輕量級鎖的時候，另一個線程雖然是自旋，但自旋不會一直持續(xù)下去，當自旋一定次數(shù)的時候，還沒有獲取到鎖，就會進入阻塞，該鎖膨脹為重量級鎖。重量級鎖會讓其他申請的線程進入阻塞，性能降低。
?synchronized的執(zhí)行過程：?
檢測Mark Word里面是不是當前線程的ID，如果是，表示當前線程處于偏向鎖?
如果不是，則使用CAS將當前線程的ID替換Mard Word，如果成功則表示當前線程獲得偏向鎖，置偏向標志位1?
?如果失敗，則說明發(fā)生競爭，撤銷偏向鎖，進而升級為輕量級鎖。
?當前線程使用CAS將對象頭的Mark Word替換為鎖記錄指針，如果成功，當前線程獲得鎖
?如果失敗，表示其他線程競爭鎖，當前線程便嘗試使用自旋來獲取鎖。
?如果自旋成功則依然處于輕量級狀態(tài)。?
?如果自旋失敗，則升級為重量級鎖。
?Ps：?CAS：即CompareAndSwap縮寫，CAS需要有3個操作數(shù)：內(nèi)存地址V，舊的預(yù)期值A(chǔ)，即將要更新的目標值B。CAS指令執(zhí)行時，當且僅當內(nèi)存地址V的值與預(yù)期值A(chǔ)相等時，將內(nèi)存地址V的值修改為B，否則就什么都不做。整個比較并替換的操作是一個原子操作。（AtomicInteger）
自旋鎖：假設(shè)持有鎖的線程能在很短時間內(nèi)釋放鎖資源，那么那些等待競爭鎖的線程就不需要做內(nèi)核態(tài)和用戶態(tài)之間的切換進入阻塞掛起狀態(tài)，只需要自旋（如while循環(huán)空轉(zhuǎn)），等持有鎖的線程釋放鎖后即可立即獲取鎖，這樣就避免用戶線程和內(nèi)核的切換的消耗。自旋是需要消耗cup的，但不能一直占用cup自旋做無用功，所以需要設(shè)定一個自旋等待的最大時間?
此外鎖還具有多種分類和分類帶來的鎖名詞
?宏觀設(shè)計理念分類——樂觀鎖和悲觀鎖
?從其它等待中的線程是否按順序獲取鎖的角度劃分——公平鎖與非公平鎖
?從能否有多個線程持有同一把鎖的角度劃分——互斥鎖
?從一個線程能否遞歸獲取自己的鎖的角度劃分——重入鎖（遞歸鎖）
?從編譯器優(yōu)化的角度劃分——鎖消除和鎖粗化
?在不同的位置使用synchronized——類鎖和對象鎖
鎖優(yōu)化：
?減少鎖的持有時間：例如避免給整個方法加鎖
?減小鎖的粒度：將大對象，拆成小對象，大大增加并行度，降低鎖競爭.如此一來偏向鎖，輕量級鎖成功率提高.（代表類ConcurrentHashMap）
?讀寫分離鎖替代獨占鎖：讀-讀不互斥，讀-寫互斥，寫-寫互斥
?鎖分離：在讀寫鎖的思想上做進一步的延伸,根據(jù)不同的功能拆分不同的鎖,進行有效的鎖分離.（代表類LinkedBlockingQueue）
?鎖粗化：同一個鎖不停的進行請求
同步和釋放, 其本身也會消耗系統(tǒng)寶貴的資源,反而不利于性能的優(yōu)化
?無鎖：鎖相比,使用CAS操作,由于其非阻塞性,因此不存在死鎖問題,同時線程之間的相互影響,?也遠小于鎖的方式.使用無鎖的方案,可以減少鎖競爭以及線程頻繁調(diào)度帶來的系統(tǒng)開銷.
關(guān)于線程的使用注意事項
在《阿里巴巴android開發(fā)手冊》有提到
關(guān)于線程池的使用注意
關(guān)于對象池復(fù)用，在《effective java》書中也有提到
參考資料：
Java線程池實現(xiàn)原理與源碼解析(jdk1.8)https://blog.csdn.net/programmer_at/article/details/79799267#4-threadpoolexecutor%E6%BA%90%E7%A0%81
線程池的工作原理與源碼解讀https://www.cnblogs.com/qingquanzi/p/8146638.html
