android創建線程

Ⅰ 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 中線程可分為 主線程 和 子線程 兩類，其中主線程也就是 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創建子線程和回調主線程的幾種方式

在一個Android 程序開始運行的時候，會單獨啟動一個Process。默認的情況下，所有這個程序中的Activity或者Service（Service和 Activity只是Android提供的Components中的兩種，除此之外還有Content Provider和Broadcast Receiver）都會跑在這個Process。
一個Android 程序默認情況下也只有一個Process，但一個Process下卻可以有許多個Thread。在這么多Thread當中，有一個Thread，我們稱之為UI Thread。UI Thread在Android程序運行的時候就被創建，是一個Process當中的主線程Main Thread，主要是負責控制UI界面的顯示、更新和控制項交互。在Android程序創建之初，一個Process呈現的是單線程模型，所有的任務都在一個線程中運行。因此，我們認為，UI Thread所執行的每一個函數，所花費的時間都應該是越短越好。而其他比較費時的工作（訪問網路，下載數據，查詢資料庫等），都應該交由子線程去執行，以免阻塞主線程。
那麼，UI Thread如何和其他Thread一起工作呢？常用方法是：
誕生一個主線程的Handler物件，當做Listener去讓子線程能將訊息Push到主線程的Message Quene里，以便觸發主線程的handlerMessage（）函數，讓主線程知道子線程的狀態，並在主線程更新UI。

Ⅳ Android UI線程

思考：

先必須了解下面2個問題
1.顧名思義 UI線程 就是刷新UI 所在線程
2.UI是單線程刷新

1.對Activity 來說 UI線程就是其主線程
2.對View來說 UI線程就是創建ViewRootImpl所在的線程
可以通過 WindowManager 內部會創建ViewRootImpl對象

好了，進入主題。我們來慢慢揭開面紗。
我們可以分別從幾個方面切入

我們可能都有使用過 runOnUiThread 現在來看看的源碼實現。

可以從上面的源碼 看到
不是UI線程 就用Handler切到Handler所在的線程中，如果是UI線程直接就調用run方法。

Activity的創建：
1.Activity創建：mInstrumentation.newActivity
2.創建Context ：ContextImpl (r)

我們經常用這個方法乾的事情就是，要麼在onCreate中獲取View寬高的值。要麼就是在子線程中做一些耗時操作 ，然後post切到對應View所在的線程 來繪制UI操作。那麼這個對應的線程就是UI線程了。
那麼這個UI線程就一定是主線程嗎？
接來繼續來看。它的源碼View:post

mAttachInfo 在dispatchAttachedToWindow 中被賦值 ，也就是在ViewRootImpl創建的時候，所以是創建ViewRootImpl所在的線程。
attachInfo 上面時候為null 呢？在ViewRootImpl 還沒來得及創建的時候，ViewRootImpl 創建是在 「onResume" 之後。所以在 Activity 的 onCreate 去View.post 那麼AttachInfo 是為null 。
當 AttachInfo == null 那麼會調用 getRunQueue().post(action) 。
最終這個Runnable 被 緩存到 HandlerActionQueue 中。
直到ViewRootImpl 的 performTraversals 中 調用dispatchAttachedToWindow(mAttachInfo, 0);， 那麼才會去處理 RunQueue() 中的Runnable。
來張圖 便於理解這個流程

我們有時候去子線程操作UI的時候(如：requestLayout)，會很經常見到下面的 報錯日誌：
Only the original thread that created a view hierarchy can touch its views

為什麼會報這個錯誤呢？
翻譯一下：只有創建視圖層次結構的原始線程才能接觸到它的視圖。
也就是操作UI的線程要和ViewRootImpl創建的線程是同一個線程才行，並不是只有主線程才能更新UI啊。
ViewRootImpl創建的線程？那麼 ViewRootImpl 在哪裡被創建的呢？

從上圖可以看到ViewRootImpl創建最開始是從 ActivityThread 的HandleResumeActivity中開始 一直 ViewRootImpl 創建，也就是說ViewRootImpl 對應的UI線程和 ActivityThread 在同一個線程 也就是主線程。

好了 通過上面的講解，上面的問題相信你可以自己回答啦~

Ⅳ 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開發中，如何在做一些耗時的操作時，另起一個新線程

handler其實就是消息處理機制。首先在主線程也就是UI創建一個Handler對象，復寫其中的handMessage( Message msg)方法。該方法里的msg就是子線程發來的消息，表示子線程處理完了，以這個msg來通知主線程。讓主線程來作UI的繪制工作。

那麼子線程工作完了就要發消息了，比如：
run(){
data = getDataFromInternet();//耗時工作
Message msg = handler.obtainMessage(0, data);//通過handler得到消息，該消息的標識為0，消息內容是data
handler.sendMessage(msg);//發送
}
然後handler在主線程就負責接收：
public Handler handler = new Handler(){//處理UI繪制

@SuppressWarnings("unchecked")
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 0:
data = (List<Map<String, Object>>) msg.obj;
if(data == null){
Toast.makeText(AllMovieActivity.this, "網路連接失敗,獲取不到影片信息", 1).show();
}else {

adapter = new HotMoviedapter(AllMovieActivity.this, data, R.layout.allmovielist_item,
new String[] { "picurl", "chname", "director", "leadrole",
"fshowtime", "country" }, new int[] { R.id.picurl,
R.id.chname, R.id.director, R.id.leadrole,
R.id.fshowtime, R.id.country },mListView);
TextView v = new TextView(AllMovieActivity.this);
v.setHeight(80);
v.setSelectAllOnFocus(false);
mListView.addFooterView(v);
mListView.setAdapter(adapter);
}
break;

default:
break;
}
}
};

Ⅶ android創建子線程

你是要怎麼個意思？
創建子線程即就是在你的程序體（也就是MainThread）中創建子線程：
1、匿名內部類對Thread類進行覆寫：new
Thread()｛
覆寫run方法
｝.start();
2、或者
new
Thread(new
Runnable(){········}).start();套用兩層匿名內部類也可以
3、再或者就是將當前類繼承Runnable然後在當前類里覆寫上run方法，最後在需要開線程的地方寫上new
Thread(this).start();
####別忘了在更新UI的時候跳回主線程就行了，用runOnUiThread
和handle機制都可以####