線程androidrunnable

『壹』 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時間過期了才能出隊。

入隊的時候不阻塞隊列，出隊的時候，如果隊列為空或者隊列里所有元素都等待時間都沒有到期，則該線程進入阻塞狀態。

『貳』 android 強行關閉線程

這個好辦，這里有兩個線程吧，線程A
線程mSender。
設：讓線程A，監視線程mSender
第一步：
在A中定義一個變數：ExecutorService
transThread
=
Executors.newSingleThreadExecutor();
解釋：transThread
官方名稱是「單一線程池變數」，他是做什麼的呢，它就像我們給A的一塊賽車場，用來玩遙控賽車。
第二步：
在A中再定義一個變數：
Future
transPending;
解釋：transPending就像我給A一個用來控制遙控賽車的遙控器一樣
第三步：
在A中定義個線程mSender對象：
private
final
Runnable
mSender
=
new
Runnable()
{
public
void
run()
{
}};
解釋：這是你寫的對象，他就相當於我給A的一個遙控賽車。
第四步：
在A中添加如下語句：transPending
=
transThread.submit(mSender);
解釋：這一步就相當於把賽車（mSender）放入場地（第一步中我們定義的transThread），並且用遙控器「transPending」來控制他。
（註：這里你是否會有疑惑，我沒有寫"mSender.start()"之類的語句怎麼讓我的賽車跑起來啊（運行run()方法），放心，有了「transPending
=
transThread.submit(mSender);」這一步，賽車是自動跑起來的，也就是mSender會自動調用run的。）
第五步：
現在你可以用遙控器「transPending」干很多事情了
transPending.cancel(true);無論線程現在是否運行中，立刻終止。
transPending.cancel(false);當前線程若沒有運行（比如掛起狀態）就終止它。
transPending所做的不止這些。

『叄』 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里有哪些方法啟動線程

其實Android啟動線程和JAVA一樣有兩種方式，一種是直接Thread類的start方法，也就是一般寫一個自己的類來繼承Thread類。另外一種方式其實和這個差不多啊！ 那就是Runnable介面，然後把Runnable的子類對象傳遞給Thread類再創建Thread對象.總之都是需要創建Thread對象，然後調用Thread類的start方法啟動線程。區別就是，一個是直接創建Thread對象，另外一個是需要implement了Runnable介面對象作為創建Thread對象的參數。Runnable其實我們稱為線程任務。
第一種方式一般是這樣用：
Class MyThread extends Thread{
public void run(){
//你要實現的代碼
}
}
在主線程中啟動這個線程:
public class Test{
public static void main(String[] args){
new MyThread().start();//啟動了我們的線程了
}
}
2，第二種方式一般是這樣用：
public class MyRunnable implements Runnable{
public void run(){
//你需要實現的代碼
}
}
在主線程中啟動這個線程：
public class Test{
public static void main(String[] args){
Thread t=new Thread(new MyRunnable());//這里比第一種創建線程對象多了個任務對象
t.start();
}
}
這里我想說的是可能你問這個問題是接觸到了Android中的Handler概念：
其實Handler並不是開辟新線程的概念，Android主要的考慮到更新界面的問題，一般情況下，更新界面（Activity）都是在主線程中更新的，這樣就遇到了一個問題，比方說：在下載文件時候我們需要進度條顯示下載進度，界面需要更新（數據是不斷變的，也就是下載的大小是不斷變的，要是直接在主線程中更新，就會造成程序的堵塞，程序很容易崩潰，通常這樣聯網耗時的工作需要開辟另外一個線程的，這樣就不會影響主程序了），好了，到這里聯網操作一般都需要開辟新線程了吧。。
接下來就來說Handler了，剛剛我說了Handler不是開辟新線程，在我看來，Handler更像是主線程的秘書，是一個觸發器，負責管理從子線程中得到更新的數據，然後在主線程中更新界面。簡單說下進度條的那個：
下載了多少的數據都是在子線程中得到的，在子線程中通過Handler的sendMessage()方法發送得到的下載的數據，當你調用了sendMessage方法後，Handler就會回調（也就是自動調用）Handler中的 HandlerMessage方法。
我很認真寫了，希望分給我！ 要是還有不懂的，可以追問，總之Handler不是開辟線程，開辟線程的方式就和JAVA一樣的！ 千萬不要被Android中的Handler混淆。

『伍』 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里一個runnable是否在運行

th = new Thread(this);
if (!th.isAlive()) { // 假如線程不存在 線程清空running=false
if (th != null) {

}