⑴ android線程池ThreadPoolExecutor詳解
傳統的多線程是通過繼承Thread類及實現Runnable介面來實現的，每次創建及銷毀線程都會消耗資源、響應速度慢，且線程缺乏統一管理，容易出現阻塞的情況，針對以上缺點，線程池就出現了。
線程池是一個創建使用線程並能保存使用過的線程以達到復用的對象，簡單的說就是一塊緩存了一定數量線程的區域。
1.復用線程：線程執行完不會立刻退出，繼續執行其他線程；
2.管理線程：統一分配、管理、控制最大並發數；
1.降低因頻繁創建&銷毀線程帶來的性能開銷，復用緩存在線程池中的線程；
2.提高線程執行效率&響應速度，復用線程：響應速度；管理線程：優化線程執行順序，避免大量線程搶占資源導致阻塞現象；
3.提高對線程的管理度；
線程池的使用也比較簡單，流程如下：
接下來通過源碼來介紹一下ThreadPoolExecutor內部實現及工作原理。
線程池的最終實現類是ThreadPoolExecutor，通過實現可以一步一步的看到，父介面為Executor:
其他的繼承及實現關系就不一一列舉了，直接通過以下圖來看一下：
從構造方法開始看：
通過以上可以看到，在創建ThreadPoolExecutor時，對傳入的參數是有要求的：corePoolSize不能小於0；maximumPoolSize需要大於0，且需要大於等於corePoolSize；keepAliveTime大於0；workQueue、threadFactory都不能為null。
在創建完後就需要執行Runnable了，看以下execute()方法：
在execute()內部主要執行的邏輯如下：
分析點1：如果當前線程數未超過核心線程數，則將runnable作為參數執行addWorker()，true表示核心線程，false表示非核心線程；
分析點2：核心線程滿了，如果線程池處於運行狀態則往workQueue隊列中添加任務，接下來判斷是否需要拒絕或者執行addWorker()；
分析點3：以上都不滿足時 [corePoolSize=0且沒有運行的線程，或workQueue已經滿了] ，執行addWorker()添加runnable，失敗則執行拒絕策略；
總結一下：線程池對線程創建的管理，流程圖如下：
在執行addWorker時，主要做了以下兩件事：
分析點1：將runnable作為參數創建Worker對象w，然後獲取w內部的變數thread；
分析點2：調用start()來啟動thread；
在addWorker()內部會將runnable作為參數傳給Worker，然後從Worker內部讀取變數thread，看一下Worker類的實現：
Worker實現了Runnable介面，在Worker內部，進行了賦值及創建操作，先將execute()時傳入的runnable賦值給內部變數firstTask，然後通過ThreadFactory.newThread(this)創建Thread，上面講到在addWorker內部執行t.start()後，會執行到Worker內部的run()方法，接著會執行runWorker(this)，一起看一下：
前面可以看到，runWorker是執行在子線程內部，主要執行了三件事：
分析1：獲取當前線程，當執行shutdown()時需要將線程interrupt()，接下來從Worker內部取到firstTask，即execute傳入的runnable，接下來會執行；
分析2：while循環，task不空直接執行；否則執行getTask()去獲取，不為空直接執行；
分析3：對有效的task執行run()，由於是在子線程中執行，因此直接run()即可，不需要start()；
前面看到，在while內部有執行getTask()，一起看一下：
getTask()是從workQueue內部獲取接下來需要執行的runnable，內部主要做了兩件事：
分析1：先獲取到當前正在執行工作的線程數量wc，通過判斷allowCoreThreadTimeOut[在創建ThreadPoolExecutor時可以進行設置]及wc > corePoolSize來確定timed值；
分析2：通過timed值來決定執行poll()或者take()，如果WorkQueue中有未執行的線程時，兩者作用是相同的，立刻返回線程；如果WorkQueue中沒有線程時，poll()有超時返回，take()會一直阻塞；如果allowCoreThreadTimeOut為true，則核心線程在超時時間沒有使用的話，是需要退出的；wc > corePoolSize時，非核心線程在超時時間沒有使用的話，是需要退出的；
allowCoreThreadTimeOut是可以通過以下方式進行設置的：
如果沒有進行設置，那麼corePoolSize數量的核心線程會一直存在。
總結一下：ThreadPoolExecutor內部的核心線程如何確保一直存在，不退出？
上面分析已經回答了這個問題，每個線程在執行時會執行runWorker()，而在runWorker()內部有while()循環會判斷getTask()，在getTask()內部會對當前執行的線程數量及allowCoreThreadTimeOut進行實時判斷，如果工作數量大於corePoolSize且workQueue中沒有未執行的線程時，會執行poll()超時退出；如果工作數量不大於corePoolSize且workQueue中沒有未執行的線程時，會執行take()進行阻塞，確保有corePoolSize數量的線程阻塞在runWorker()內部的while()循環不退出。
如果需要關閉線程池，需要如何操作呢，看一下shutdown()方法：
以上可以看到，關閉線程池的原理：a. 遍歷線程池中的所有工作線程；b. 逐個調用線程的interrupt()中斷線程（註：無法響應中斷的任務可能永遠無法終止）
也可調用shutdownNow()來關閉線程池，二者區別：
shutdown()：設置線程池的狀態為SHUTDOWN，然後中斷所有沒有正在執行任務的線程；
shutdownNow()：設置線程池的狀態為STOP，然後嘗試停止所有的正在執行或暫停任務的線程，並返回等待執行任務的列表；
使用建議：一般調用shutdown()關閉線程池；若任務不一定要執行完，則調用shutdownNow()；
總結一下：ThreadPoolExecutor在執行execute()及shutdown()時的調用關系，流程圖如下：
線程池可以通過Executors來進行不同類型的創建，具體分為四種不同的類型，如下：
可緩存線程池：不固定線程數量，且支持最大為Integer.MAX_VALUE的線程數量：
1、線程數無限制
2、有空閑線程則復用空閑線程，若無空閑線程則新建線程
3、一定程度上減少頻繁創建/銷毀線程，減少系統開銷
固定線程數量的線程池：定長線程池
1、可控制線程最大並發數(同時執行的線程數)
2、超出的線程會在隊列中等待。
單線程化的線程池：可以理解為線程數量為1的FixedThreadPool
1、有且僅有一個工作線程執行任務
2、所有任務按照指定順序執行，即遵循隊列的入隊出隊規則
定時以指定周期循環執行任務
一般來說，等待隊列 BlockingQueue 有: ArrayBlockingQueue 、 LinkedBlockingQueue 與 SynchronousQueue 。
假設向線程池提交任務時，核心線程都被佔用的情況下:
ArrayBlockingQueue ：基於數組的阻塞隊列，初始化需要指定固定大小。
當使用此隊列時，向線程池提交任務，會首先加入到等待隊列中，當等待隊列滿了之後，再次提交任務，嘗試加入隊列就會失敗，這時就會檢查如果當前線程池中的線程數未達到最大線程，則會新建線程執行新提交的任務。所以最終可能出現後提交的任務先執行，而先提交的任務一直在等待。
LinkedBlockingQueue ：基於鏈表實現的阻塞隊列，初始化可以指定大小，也可以不指定。
當指定大小後，行為就和 ArrayBlockingQueue一致。而如果未指定大小，則會使用默認的 Integer.MAX_VALUE 作為隊列大小。這時候就會出現線程池的最大線程數參數無用，因為無論如何，向線程池提交任務加入等待隊列都會成功。最終意味著所有任務都是在核心線程執行。如果核心線程一直被占，那就一直等待。
SynchronousQueue ：無容量的隊列。
使用此隊列意味著希望獲得最大並發量。因為無論如何，向線程池提交任務，往隊列提交任務都會失敗。而失敗後如果沒有空閑的非核心線程，就會檢查如果當前線程池中的線程數未達到最大線程，則會新建線程執行新提交的任務。完全沒有任何等待，唯一制約它的就是最大線程數的個數。因此一般配合Integer.MAX_VALUE就實現了真正的無等待。
但是需要注意的是， 進程的內存是存在限制的，而每一個線程都需要分配一定的內存。所以線程並不能無限個。
⑵ Android多線程的四種方式：Handler、AsyncTask、ThreadPoolExector、IntentService
非同步通信機制，將工作線程中需更新UI的操作信息 傳遞到 UI主線程，從而實現 工作線程對UI的更新處理，最終實現非同步消息的處理。Handler不僅僅能將子線程的數據傳遞給主線程，它能實現任意兩個線程的數據傳遞。
（1）Message
Message 可以在線程之間傳遞消息。可以在它的內部攜帶少量數據，用於在不同線程之間進行數據交換。除了 what 欄位，還可以使用 arg1 和 arg2 來攜帶整型數據，使用 obj 來攜帶 Object 數據。
（2） Handler
Handler 作為處理中心，用於發送（sendMessage 系列方法）與處理消息（handleMessage 方法）。
（3） MessageQueue
MessageQueue 用於存放所有通過 Handler 發送的消息。這部分消息會一直存放在消息隊列中，直到被處理。每個線程中只會有一個 MessageQueue 對象
（4） Looper
Looper 用於管理 MessageQueue 隊列，Looper對象通過loop()方法開啟了一個死循環——for (;;)｛｝，不斷地從looper內的MessageQueue中取出Message，並傳遞到 Handler 的 handleMessage() 方法中。每個線程中只會有一個 Looper 對象。
AsyncTask 是一種輕量級的任務非同步類，可以在後檯子線程執行任務，且將執行進度及執行結果傳遞給 UI 線程。
（1）onPreExecute()
在 UI 線程上工作，在任務執行 doInBackground() 之前調用。此步驟通常用於設置任務，例如在用戶界面中顯示進度條。
（2）doInBackground(Params... params)
在子線程中工作，在 onPreExecute() 方法結束後執行，這一步被用於在後台執行長時間的任務，Params 參數通過 execute(Params) 方法被傳遞到此方法中。任務執行結束後，將結果傳遞給 onPostExecute(Result) 方法，同時我們可以通過 publishProgress(Progress) 方法，將執行進度發送給 onProgressUpdate(Progress) 方法。
（3）onProgressUpdate(Progress... values)
在 UI 線程上工作，會在 doInBackground() 中調用 publishProgress(Progress) 方法後執行，此方法用於在後台計算仍在執行時(也就是 doInBackgound() 還在執行時)將計算執行進度通過 UI 顯示出來。例如，可以通過動畫進度條或顯示文本欄位中的日誌，從而方便用戶知道後台任務執行的進度。
（4）onPostExecute(Result result)
在 UI 線程上工作，在任務執行完畢（即 doInBackground(Result) 執行完畢）並將執行結果傳過來的時候工作。
使用規則：
（1）AsyncTask 是個抽象類，所以要創建它的子類實現抽象方法
（1）AsyncTask 類必須是在 UI 線程中被載入，但在Android 4.1（API 16）開始，就能被自動載入完成。
（2）AsyncTask 類的實例對象必須在 UI 線程中被創建。
（3）execute() 方法必須是在 UI 線程中被調用。
（4）不要手動調用方法 onPreExecute()、onPostExecute()、doInBackground()、onProgressUpdate()
（5）任務只能執行一次(如果嘗試第二次執行，將拋出異常)。即一個AsyncTask對象只能調用一次execute()方法。
原理：
其源碼中原理還是 Thread 與 Handler 的實現，其包含 兩個線程池，一個 Handler，如下所示：
名稱類型作用
SERIAL_EXECUTOR線程池分發任務，串列分發，一次只分發一個任務
THREAD_POOL_EXECUTOR線程池執行任務，並行執行，執行的任務由 SERIAL_EXECUTOR 分發
InternalHandlerHandler負責子線程與主線程的溝通，通知主線程做 UI 工作
一方面減少了每個並行任務獨自建立線程的開銷，另一方面可以管理多個並發線程的公共資源，從而提高了多線程的效率。所以ThreadPoolExecutor比較適合一組任務的執行。Executors利用工廠模式對ThreadPoolExecutor進行了封裝。
Executors提供了四種創建ExecutorService的方法，他們的使用場景如下：
1. Executors.newFixedThreadPool()
創建一個定長的線程池，每提交一個任務就創建一個線程，直到達到池的最大長度，這時線程池會保持長度不再變化。
當線程處於空閑狀態時，它們並不會被回收，除非線程池被關閉。當所有的線程都處於活動狀態時，新任務都會處於等待狀態，直到有線程空閑出來。
只有核心線程並且不會被回收，能夠更加快速的響應外界的請求。
2. Executors.newCachedThreadPool()
創建一個可緩存的線程池，如果當前線程池的長度超過了處理的需要時，它可以靈活的回收空閑的線程，當需要增加時，它可以靈活的添加新的線程，而不會對池的長度作任何限制
線程數量不定的線程池，只有非核心線程，最大線程數為 Integer.MAX_VALUE。當線程池中的線程都處於活動狀態時，線程池會創建新的線程來處理新任務，否則利用空閑的線程來處理新任務。線程池中的空閑線程具有超時機制，為 60s。
任務隊列相當於一個空集合，導致任何任務都會立即被執行，適合執行大量耗時較少的任務。當整個線程池都處於限制狀態時，線程池中的線程都會超時而被停止。
3. Executors.newScheledThreadPool()
創建一個定長的線程池，而且支持定時的以及周期性的任務執行，類似於Timer。
非核心線程數沒有限制，並且非核心線程閑置的時候立即回收，主要用於執行定時任務和具有固定周期的重復任務。
4. Executors.newSingleThreadExecutor()
創建一個單線程化的executor，它只創建唯一的worker線程來執行任務
只有一個核心線程，保證所有的任務都在一個線程中順序執行，意義在於不需要處理線程同步的問題。
一般用於執行後台耗時任務，當任務執行完成會自動停止；同時由於它是一個服務，優先順序要遠遠高於線程，更不容易被系統殺死，因此比較適合執行一些高優先順序的後台任務。
使用步驟：創建IntentService的子類，重寫onHandleIntent方法，在onHandleIntent中執行耗時任務
原理：在源碼實現上，IntentService封裝了HandlerThread和Handler。onHandleIntent方法結束後會調用IntentService的stopSelf(int startId)方法嘗試停止服務。
IntentService的內部是通過消息的方式請求HandlerThread執行任務，HandlerThread內部又是一種使用Handler的Thread，這就意味著IntentService和Looper一樣是順序執行後台任務的
（HandlerThread：封裝了Handler + ThreadHandlerThread適合在有需要一個工作線程（非UI線程）+任務的等待隊列的形式，優點是不會有堵塞，減少了對性能的消耗，缺點是不能同時進行多個任務的處理，需要等待進行處理。處理效率低，可以當成一個輕量級的線程池來用）
⑶ Android線程池的使用
在Android中有主線程和子線程的區分。主線程又稱為UI線程，主要是處理一些和界面相關的事情，而子線程主要是用於處理一些耗時比較大的一些任務，例如一些網路操作，IO請求等。如果在主線程中處理這些耗時的任務，則有可能會出現ANR現象（App直接卡死）。
線程池，從名字的表明含義上我們知道線程池就是包含線程的一個池子，它起到新建線程、管理線程、調度線程等作用。
既然Android中已經有了線程的概念，那麼為什麼需要使用線程池呢？我們從兩個方面給出使用線程池的原因。
在Android中線程池就是ThreadPoolExecutor對象。我們先來看一下ThreadPoolExecutor的構造函數。
我們分別說一下當前的幾個參數的含義：
第一個參數corePoolSize為 核心線程數 ，也就是說線程池中至少有這么多的線程，即使存在的這些線程沒有執行任務。但是有一個例外就是，如果在線程池中設置了allowCoreThreadTimeOut為true，那麼在 超時時間（keepAliveTime） 到達後核心線程也會被銷毀。
第二個參數maximumPoolSize為 線程池中的最大線程數 。當活動線程數達到這個數後，後續添加的新任務會被阻塞。
第三個參數keepAliveTime為 線程的保活時間 ，就是說如果線程池中有多於核心線程數的線程，那麼在線程沒有任務的那一刻起開始計時，如果超過了keepAliveTime，還沒有新的任務過來，則該線程就要被銷毀。同時如果設置了allowCoreThreadTimeOut為true，該時間也就是上面第一條所說的 超時時間 。
第四個參數unit為 第三個參數的計時單位 ，有毫秒、秒等。
第五個參數workQueue為 線程池中的任務隊列 ，該隊列持有由execute方法傳遞過來的Runnable對象（Runnable對象就是一個任務）。這個任務隊列的類型是BlockQueue類型，也就是阻塞隊列，當隊列的任務數為0時，取任務的操作會被阻塞；當隊列的任務數滿了（活動線程達到了最大線程數），添加操作就會阻塞。
第六個參數threadFactory為 線程工廠 ，當線程池需要創建一個新線程時，使用線程工廠來給線程池提供一個線程。
第七個參數handler為 拒絕策略 ，當線程池使用有界隊列時（也就是第五個參數），如果隊列滿了，任務添加到線程池的時候的一個拒絕策略。
可以看到FixedThreadPool的構建調用了ThreadPoolExecutor的構造函數。從上面的調用中可以看出FixedThreadPool的幾個特點：
可以看到CacheThreadPool的構建調用了ThreadPoolExecutor的構造函數。從上面的調用中可以看出CacheThreadPool的幾個特點：
可以看到ScheledThreadPoolExecutor的構建調用了ThreadPoolExecutor的構造函數。從上面的調用中可以看出ScheledThreadPoolExecutor的幾個特點：
可以看到SingleThreadExecutor的構建調用了ThreadPoolExecutor的構造函數。從上面的調用中可以看出SingleThreadExecutor的幾個特點：
⑷ android如何使用多線程及socket發送指令
1、後台服務是service，沒有界面 2、主線程要給後台service傳遞一個對象可以使用通知也就是notifation 方法：在主線程生成一個通知管理器對象notifationmanager，把socket對象以通知消息的形式發送給後台service，詳細的可以看看安卓巴士教程：http://www.apkbus.com/thread-463757-1-1.html
⑸ Android進程間和線程間通信方式
進程：是具有一定獨立功能的程序關於某個數據集合上的一次運行活動，進程是系統進行資源分配和調度的一個獨立單位。
線程：是進程的一個實體,是CPU調度和分派的基本單位,它是比進程更小的能獨立運行的基本單位。線程自己基本上不擁有系統資源,只擁有一些在運行中必不可少的資源(如程序計數器,一組寄存器和棧)，但是它可與同屬一個進程的其他的線程共享進程所擁有的全部資源。
區別：
（1）、一個程序至少有一個進程，一個進程至少有一個線程；
（2）、線程的劃分尺度小於進程，使得多線程程序的並發性高；
（3）、進程在執行過程中擁有獨立的內存單元，而多個線程共享內存，但線程之間沒有單獨的地址空間，一個線程死掉就等於整個進程死掉。
---------------------
一、Android進程間通信方式
1.Bundle
由於Activity，Service，Receiver都是可以通過Intent來攜帶Bundle傳輸數據的，所以我們可以在一個進程中通過Intent將攜帶數據的Bundle發送到另一個進程的組件。
缺點：無法傳輸Bundle不支持的數據類型。
2.ContentProvider
ContentProvider是Android四大組件之一，以表格的方式來儲存數據，提供給外界，即Content Provider可以跨進程訪問其他應用程序中的數據。用法是繼承ContentProvider，實現onCreate,query,update,insert,delete和getType方法，onCreate是負責創建時做一些初始化的工作，增刪查改的方法就是對數據的查詢和修改，getType是返回一個String，表示Uri請求的類型。注冊完後就可以使用ContentResolver去請求指定的Uri。
3.文件
兩個進程可以到同一個文件去交換數據，我們不僅可以保存文本文件，還可以將對象持久化到文件，從另一個文件恢復。要注意的是，當並發讀/寫時可能會出現並發的問題。
4.Broadcast
Broadcast可以向android系統中所有應用程序發送廣播，而需要跨進程通訊的應用程序可以監聽這些廣播。
5.AIDL方式
Service和Content Provider類似，也可以訪問其他應用程序中的數據，Content Provider返回的是Cursor對象，而Service返回的是java對象，這種可以跨進程通訊的服務叫AIDL服務。
AIDL通過定義服務端暴露的介面，以提供給客戶端來調用，AIDL使伺服器可以並行處理，而Messenger封裝了AIDL之後只能串列運行，所以Messenger一般用作消息傳遞。
6.Messenger
Messenger是基於AIDL實現的，服務端（被動方）提供一個Service來處理客戶端（主動方）連接，維護一個Handler來創建Messenger，在onBind時返回Messenger的binder。
雙方用Messenger來發送數據，用Handler來處理數據。Messenger處理數據依靠Handler，所以是串列的，也就是說，Handler接到多個message時，就要排隊依次處理。
7.Socket
Socket方法是通過網路來進行數據交換，注意的是要在子線程請求，不然會堵塞主線程。客戶端和服務端建立連接之後即可不斷傳輸數據，比較適合實時的數據傳輸
二、Android線程間通信方式
一般說線程間通信主要是指主線程（也叫UI線程）和子線程之間的通信，主要有以下兩種方式：
1.AsyncTask機制
AsyncTask，非同步任務，也就是說在UI線程運行的時候，可以在後台的執行一些非同步的操作；AsyncTask可以很容易且正確地使用UI線程，AsyncTask允許進行後台操作，並在不顯示使用工作線程或Handler機制的情況下，將結果反饋給UI線程。但是AsyncTask只能用於短時間的操作（最多幾秒就應該結束的操作），如果需要長時間運行在後台，就不適合使用AsyncTask了，只能去使用Java提供的其他API來實現。
2.Handler機制
Handler，繼承自Object類，用來發送和處理Message對象或Runnable對象；Handler在創建時會與當前所在的線程的Looper對象相關聯(如果當前線程的Looper為空或不存在，則會拋出異常，此時需要在線程中主動調用Looper.prepare()來創建一個Looper對象)。使用Handler的主要作用就是在後面的過程中發送和處理Message對象和讓其他的線程完成某一個動作（如在工作線程中通過Handler對象發送一個Message對象，讓UI線程進行UI的更新，然後UI線程就會在MessageQueue中得到這個Message對象（取出Message對象是由其相關聯的Looper對象完成的），並作出相應的響應）。
三、Android兩個子線程之間通信
面試的過程中，有些面試官可能會問Android子線程之間的通信方式，由於絕大部分程序員主要關注的是Android主線程和子線程之間的通信，所以這個問題很容易讓人懵逼。
主線程和子線程之間的通信可以通過主線程中的handler把子線程中的message發給主線程中的looper，或者，主線程中的handler通過post向looper中發送一個runnable。但looper默認存在於main線程中，子線程中沒有Looper，該怎麼辦呢？其實原理很簡單，把looper綁定到子線程中，並且創建一個handler。在另一個線程中通過這個handler發送消息，就可以實現子線程之間的通信了。
子線程創建handler的兩種方式：
方式一：給子線程創建Looper對象：
new Thread(new Runnable() {
public void run() {
Looper.prepare(); // 給這個Thread創建Looper對象，一個Thead只有一個Looper對象
Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
Toast.makeText(getApplicationContext(), "handleMessage", Toast.LENGTH_LONG).show();
}
};
handler.sendEmptyMessage(1);
Looper.loop(); // 不斷遍歷MessageQueue中是否有消息
};
}).start();
---------------------
方式二：獲取主線程的looper，或者說是UI線程的looper：
new Thread(new Runnable() {
public void run() {
Handler handler = new Handler(Looper.getMainLooper()){ // 區別在這！！！
@Override
public void handleMessage(Message msg) {
Toast.makeText(getApplicationContext(), "handleMessage", Toast.LENGTH_LONG).show();
}
};
handler.sendEmptyMessage(1);
};
}).start();
---------------------
⑹ Android開發之路-多線程
多線程作為Android開發中相對而言較為高階的知識，其中用到相關的知識點是非常的多，所以在我們需要進行設計或者寫多線程的代碼就必須要進行相對謹慎的處理，這樣就由必要對其要有著比較系統化的認知
我們一般將Android應用分成為兩種：主線程和工作線程；主線程主要是用來進行初始化UI，而工作線程主要是進行耗時操作，例如讀取資料庫，網路連接等
Android系統是以進程為單位來對應用程序資源進行限制，這個問題的可以解釋為：一個進程最多能夠開幾個線程？最好能開幾個？但實則這個是沒有上限這一說，主要是因為資源的限制
Android中關於主線程的理解：Android的主線程是UI線程，在Android中，四大組件運行在主線程中，在主線程中做耗時操作會導致程序出現卡頓甚至出現ANR異常，一個.
在一個程序中，這些獨立運行的程序片斷叫作「線程」(Thread)，利用它編程的概念就叫作「多線程處理」。多線程處理一個常見的例子就是用戶界面。
線程總的來就是進程的一個實體，是CPU進行分派和調度的基本單位，擁有著比進程更小且能夠獨立運行的基本單位，線程本身基本上是不擁有系統資源，僅擁有一點在運行過程中必須擁有的資源，但它可與同屬一個進程中的其他進程進行共享其所擁有的所有資源
線程狀態有些地方將之分為5中狀態，而且在Java Jdk中線程被其定義為6中狀態，我們可以對其進行類比
普遍定義的5中狀態：新建，就緒，運行，阻塞， 死亡
Java Jdk 定義狀態
線程阻塞是指在某一時刻的某一個線程在進行運行一段代碼的情況下，突然另一個線程也要進行運行，但在運行過程中，那個線程執行完全運行之前，另一個線程是不可能獲取到CPU的執行權，就會導致線路阻塞的出現
死鎖也稱之為抱死，意思就是說一個進程鎖定了另外一個進程所需要的頁或表是，但第二個進程同時又鎖定了第一個進程所需的一頁，這樣就會出現死鎖現象
簡要介紹實現線程的三種方式：繼承Thread，實現runnable，實現callable。這里有一點需要注意的是，實現callable是與線程池相關聯的而callable很重要的一個特性是其帶有返回值。當我們只需實現單線程時實現runnable更加利於線程程序的拓展
在線程開啟之前進行調用 thread.setDaemon(true); 將thread設定成當前線程中的守護線程 使用案例
線程讓步【yield方法】讓當前線程釋放CPU資源，讓其他線程搶占
這種具體某個對象鎖 wait & notify 方法與Condition 的 await以及signal方法類似； 全面這種方法的阻塞等待都可以是釋放鎖，而且在喚醒後，這種線程都是能夠獲取鎖資源的，而這個門栓就跟閥門類似
⑺ Android 中的「子線程」解析
Android 中線程可分為 主線程 和 子線程 兩類，其中主線程也就是 UI線程 ，它的主要這作用就是運行四大組件、處理界面交互。子線程則主要是處理耗時任務，也是我們要重點分析的。
首先 Java 中的各種線程在 Android 里是通用的，Android 特有的線程形態也是基於 Java 的實現的，所以有必要先簡單的了解下 Java 中的線程，本文主要包括以下內容：
在 Java 中要創建子線程可以直接繼承 Thread 類，重寫 run() 方法：
或者實現 Runnable 介面，然後用Thread執行Runnable，這種方式比較常用：
簡單的總結下：
Callable 和 Runnable 類似，都可以用來處理具體的耗時任務邏輯的，但是但具體的差別在哪裡呢？看一個小例子：
定義 MyCallable 實現了 Callable 介面，和之前 Runnable 的 run() 方法對比下， call() 方法是有返回值的哦，泛型就是返回值的類型：
一般會通過線程池來執行 Callable （線程池相關內容後邊會講到），執行結果就是一個 Future 對象：
可以看到，通過線程池執行 MyCallable 對象返回了一個 Future 對象，取出執行結果。
Future 是一個介面，從其內部的方法可以看出它提供了取消任務（有坑！！！）、判斷任務是否完成、獲取任務結果的功能：
Future 介面有一個 FutureTask 實現類，同時 FutureTask 也實現了 Runnable 介面，並提供了兩個構造函數：
用 FutureTask 一個參數的構造函數來改造下上邊的例子：
FutureTask 內部有一個 done() 方法，代表 Callable 中的任務已經結束，可以用來獲取執行結果：
所以 Future + Callable 的組合可以更方便的獲取子線程任務的執行結果，更好的控制任務的執行，主要的用法先說這么多了，其實 AsyncTask 內部也是類似的實現！
注意， Future 並不能取消掉運行中的任務，這點在後邊的 AsyncTask 解析中有提到。
Java 中線程池的具體的實現類是 ThreadPoolExecutor ，繼承了 Executor 介面，這些線程池在 Android 中也是通用的。使用線程池的好處：
常用的構造函數如下：
一個常規線程池可以按照如下方式來實現：
執行任務：
基於 ThreadPoolExecutor ，系統擴展了幾類具有新特性的線程池：
線程池可以通過 execute() 、 submit() 方法開始執行任務，主要差別從方法的聲明就可以看出，由於 submit() 有返回值，可以方便得到任務的執行結果：
要關閉線程池可以使用如下方法：
IntentService 是 Android 中一種特殊的 Service，可用於執行後台耗時任務，任務結束時會自動停止，由於屬於系統的四大組件之一，相比一般線程具有較高的優先順序，不容易被殺死。用法和普通 Service 基本一致，只需要在 onHandleIntent() 中處理耗時任務即可：
至於 HandlerThread，它是 IntentService 內部實現的重要部分，細節內容會在 IntentService 源碼中說到。
IntentService 首次創建被啟動的時候其生命周期方法 onCreate() 會先被調用，所以我們從這個方法開始分析：
這里出現了 HandlerThread 和 ServiceHandler 兩個類，先搞明白它們的作用，以便後續的分析。
首先看 HandlerThread 的核心實現：
首先它繼承了 Thread 類，可以當做子線程來使用，並在 run() 方法中創建了一個消息循環系統、開啟消息循環。
ServiceHandler 是 IntentService 的內部類，繼承了 Handler，具體內容後續分析：
現在回過頭來看 onCreate() 方法主要是一些初始化的操作， 首先創建了一個 thread 對象，並啟動線程，然後用其內部的 Looper 對象 創建一個 mServiceHandler 對象，將子線程的 Looper 和 ServiceHandler 建立了綁定關系，這樣就可以使用 mServiceHandler 將消息發送到子線程去處理了。
生命周期方法 onStartCommand() 方法會在 IntentService 每次被啟動時調用，一般會這里處理啟動 IntentService 傳遞 Intent 解析攜帶的數據：
又調用了 start() 方法：
就是用 mServiceHandler 發送了一條包含 startId 和 intent 的消息，消息的發送還是在主線程進行的，接下來消息的接收、處理就是在子線程進行的：
當接收到消息時，通過 onHandleIntent() 方法在子線程處理 intent 對象， onHandleIntent() 方法執行結束後，通過 stopSelf(msg.arg1) 等待所有消息處理完畢後終止服務。
為什麼消息的處理是在子線程呢？這里涉及到 Handler 的內部消息機制，簡單的說，因為 ServiceHandler 使用的 Looper 對象就是在 HandlerThread 這個子線程類里創建的，並通過 Looper.loop() 開啟消息循環，不斷從消息隊列（單鏈表）中取出消息，並執行，截取 loop() 的部分源碼：
dispatchMessage() 方法間接會調用 handleMessage() 方法，所以最終 onHandleIntent() 就在子線程中劃線執行了，即 HandlerThread 的 run() 方法。
這就是 IntentService 實現的核心，通過 HandlerThread + Hanlder 把啟動 IntentService 的 Intent 從主線程切換到子線程，實現讓 Service 可以處理耗時任務的功能！
AsyncTask 是 Android 中輕量級的非同步任務抽象類，它的內部主要由線程池以及 Handler 實現，在線程池中執行耗時任務並把結果通過 Handler 機制中轉到主線程以實現UI操作。典型的用法如下：
從 Android3.0 開始，AsyncTask 默認是串列執行的：
如果需要並行執行可以這么做：
AsyncTask 的源碼不多，還是比較容易理解的。根據上邊的用法，可以從 execute() 方法開始我們的分析：
看到 @MainThread 註解了嗎？所以 execute() 方法需要在主線程執行哦！
進而又調用了 executeOnExecutor() ：
可以看到，當任務正在執行或者已經完成，如果又被執行會拋出異常！回調方法 onPreExecute() 最先被執行了。
傳入的 sDefaultExecutor 參數，是一個自定義的串列線程池對象，所有任務在該線程池中排隊執行：
可以看到 SerialExecutor 線程池僅用於任務的排隊， THREAD_POOL_EXECUTOR 線程池才是用於執行真正的任務，就是我們線程池部分講到的 ThreadPoolExecutor ：
再回到 executeOnExecutor() 方法中，那麼 exec.execute(mFuture) 就是觸發線程池開始執行任務的操作了。
那 executeOnExecutor() 方法中的 mWorker 是什麼？ mFuture 是什麼？答案在 AsyncTask 的構造函數中：
原來 mWorker 是一個 Callable 對象， mFuture 是一個 FutureTask 對象，繼承了 Runnable 介面。所以 mWorker 的 call() 方法會在 mFuture 的 run() 方法中執行，所以 mWorker 的 call() 方法在線程池得到執行！
同時 doInBackground() 方法就在 call() 中方法，所以我們自定義的耗時任務邏輯得到執行，不就是我們第二部分講的那一套嗎！
doInBackground() 的返回值會傳遞給 postResult() 方法：
就是通過 Handler 將最終的耗時任務結果從子線程發送到主線程，具體的過程是這樣的， getHandler() 得到的就是 AsyncTask 構造函數中初始化的 mHandler ， mHander 又是通過 getMainHandler() 賦值的：
可以在看到 sHandler 是一個 InternalHandler 類對象：
所以 getHandler() 就是在得到在主線程創建的 InternalHandler 對象，所以
就可以完成耗時任務結果從子線程到主線程的切換，進而可以進行相關UI操作了。
當消息是 MESSAGE_POST_RESULT 時，代表任務執行完成， finish() 方法被調用：
如果任務沒有被取消的話執行 onPostExecute() ，否則執行 onCancelled() 。
如果消息是 MESSAGE_POST_PROGRESS ， onProgressUpdate() 方法被執行，根據之前的用法可以 onProgressUpdate() 的執行需要我們手動調用 publishProgress() 方法，就是通過 Handler 來發送進度數據：
進行中的任務如何取消呢？AsyncTask 提供了一個 cancel(boolean mayInterruptIfRunning) ，參數代表是否中斷正在執行的線程任務，但是呢並不靠譜， cancel() 的方法注釋中有這么一段：
大致意思就是調用 cancel() 方法後， onCancelled(Object) 回調方法會在 doInBackground() 之後被執行而 onPostExecute() 將不會被執行，同時你應該 doInBackground() 回調方法中通過 isCancelled() 來檢查任務是否已取消，進而去終止任務的執行！
所以只能自己動手了：
AsyncTask 整體的實現流程就這些了，源碼是最好的老師，自己跟著源碼走一遍有些問題可能就豁然開朗了！
⑻ Android中的線程池
線程池的好處
1、重用線程池中的線程，避免線程的創建與銷毀帶來的性能開銷
2、能有效控制線程池的最大並發數，避免大量線程因搶占資源而導致的阻塞
3、能對線程進行簡單的管理，提供定時或者指定間隔時間、循環執行等操作
線程池的概率來自於java的Executor介面，實現類是ThreadPoolExecutor, 它提供一系列的參數來配置線程池，以此構建不同的線程池。Android的線程池分4類，都是通過Executors所提供的工廠方法來得到。
ThreadPoolExecutor有四個構造函數，下面這個是最常用的
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnnable> workQueue, ThreadFactory threadFactory)
corePoolSize
線程池中的核心線程數，默認情況下核心線程會在線程池中一直存活，即使他們處於閑置狀態。如果設置ThreadPoolExecutor 中的allowCoreThreadTimeOut = true, 核心線程在等待新任務到來時有超時機制，時間超過keepAliveTime所指定的時間後，核心線程會終止。
maximumPoolSize
最大線程數
keepAliveTime
非核心線程閑置的超時時間，超過這個時間，非核心線程會被回收。核心線程則要看allowCoreThreadTimeOut屬性的值。
unit
時間單位
workQueue
線程池中的工作隊列
threadFactory
線程工廠，為線程池提供創建新線程的功能。
舉個例子，我們常用的okhttp內部也是使用了線程池，它的ThreadPoolExecutor主要是定義在Dispatcher類裡面。 使用的是CachedThreadPool。
executorService = ThreadPoolExecutor(0, Int.MAX_VALUE, 60, TimeUnit.SECONDS, SynchronousQueue(), ThreadFactory("okhttp Dispatcher", false))
1、FixedThreadPool
通過Executors的newFixedThreadPool（）創建，這是一個線程數量固定的線程池，裡面所有的線程都是核心線程。
public static ExecutorService newFixedThreadPool(int nThreads){
return new ThreadPoolExecutor(nThreads, nThreads, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())
}
2、CachedThreadPool
通過Executors的newCacheThreadPool（）創建，這是一個線程數量不定的線程池，裡面所有的線程都是非核心線程。最大線程數是無限大，當線程池中的線程都處於活動狀態時，新的task會創建新的線程來處理，否則就使用空閑的線程處理，所有的線程都是60s的超時時間，超時後會自動回收。
public static ExecutorService newFixedThreadPool(){
return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>())
}
3、ScheledThreadPool
通過Executors的newScheledThreadPool（）創建, 核心線程固定，非核心線程無限大，當非核心線程空閑時，會立即被回收。適合做定時任務或者固定周期的重復任務。
public static ExecutorService newScheledThreadPool(int corePoolSize){
return new ThreadPoolExecutor(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new DelayedWorkQueue())
}
4、SingleThreadExcecutor
通過Executors的newSingleThreadPool（）創建，內部只有一個核心線程。
public static ExecutorService newFixedThreadPool(){
return new ThreadPoolExecutor(1, 1, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())
}
課外知識：LinkedBlockingQueue
LinkedBlockingQueue是由鏈表組成的阻塞隊列，內部head 指向隊列第一個元素，last指向最後一個元素。入隊和出隊都會加鎖阻塞，都是使用了不同的鎖。
DelayedWorkQueue
延時隊列，隊內元素必須是Delayed的實現類。對內元素會按照Delayed時間進行排序，對內元素只有在delayed時間過期了才能出隊。
入隊的時候不阻塞隊列，出隊的時候，如果隊列為空或者隊列里所有元素都等待時間都沒有到期，則該線程進入阻塞狀態。