android新線程

『壹』 android創建子線程

創建後台線程的方法有多種，這里說三種，可以回去試試

1、使用Android系統工具類 AsyncTask（Params，Progress，Result）
AsyncTask是一個輕量級線程，三個泛型參數分別是 Params傳入參數，int型Progress為進度條進度，Result為返回值
要使用AsyncTask，必須繼承之並復寫其中的幾個重要的函數。
onPreExecute(), 該方法將在執行實際的後台操作前被UI thread調用。可以在該方法中做一些准備工作，如在界面上顯示一個進度條。
doInBackground(Params...), 將在onPreExecute 方法執行後馬上執行，該方法運行在後台線程中。這里將主要負責執行那些很耗時的後台計算工作。可以調用 publishProgress方法來更新實時的任務進度。該方法是抽象方法，子類必須實現。
onProgressUpdate(Progress...),在publishProgress方法被調用後，UI thread將調用這個方法從而在界面上展示任務的進展情況，例如通過一個進度條進行展示。
onPostExecute(Result), 在doInBackground 執行完成後，onPostExecute 方法將被UI thread調用，後台的計算結果將通過該方法傳遞到UI thread.

註：Task必須在UI線程中創建，並調用並且只能調用一次execute方法，該方法的參數為傳入的泛型Params。
其餘函數最好不要手動調用，容易造成線程崩潰。多次調用Task，容易造成線程池溢出。

2、使用Handler和HandlerThread
誤區： Handler handler = new Handler ();
handler.post(r);
這種做法看似創建了一個線程，但實際上handler只是直接調用Runnable中的run() 方法，而不執行線程的start()函數，所以這兩句代碼執行後，程序仍然在UI線程中執行。所以我們引入HandlerThread，因為HandlerThread中有一個Looper對象，用以循環消息隊列。
為了使用Looper，必須子類化Handler，並復寫它的構造函數。
class MyHandler extends Handler{
public MyHandler() {}
public MyHandler(Looper looper){
super (looper);
}

public void handleMessage(Message msg){
//....這里運行耗時的過程
}
}
}
handleMessage(Message msg）函數用以接收消息，msg則是從UI線程中發出的消息，可以傳遞各種對象，根據這些對象和數值進行操作。
有了Handler子類，則可以在UI線程中進行創建和初始化
HandlerThread handlerThread = new HandlerThread( "backgroundThread" );
handlerThread.start();
MyHandler myHandler = new MyHandler(handlerThread.getLooper());
Message msg = myHandler.obtainMessage();
//....此處對msg進行賦值，可以創建一個Bundle進行承載
msg.sendToTarget();
之後如果需要調用線程，只要對handler傳入msg，就可以執行相應的過程了
最後，很重要的一點，HandlerThread 不隨Activity的生命周期結束而消亡，所以必須復寫Ondestory()，調用HandlerThread .stop()

3、使用線程同步 synchronized、 wait()、 notify()
使用線程同步機制synchronized實現多線程操作，相對來說比較復雜，但也是靈活性最佳、效率最高的一種做法，在產品開發當中也使用得最廣。本人水平相當有限，也只學得一點皮毛。
synchronized相當於一把鎖，當線程運行的時候，會同時有幾個線程訪問一個對象，對其進行操作或者修改。這可能引起很不良的後果（例如改變判定條件，或者在別的線程還沒使用完的時候對象已經被析構等等），所以必須對一些對象進行加鎖，保證它在同一時間只允許被一個線程訪問。
synchronized使用方法有兩種：
<1> 同步方法在方法名前加入synchronized關鍵字，則該方法在同一時間內只允許一個線程訪問它，其代碼邏輯較為簡單，但使用起來不太靈活，並且大大降低效率，耗時太長的同步方法甚至會使得多線程失去原本的意義成為單線程
<2>同步參數 對某一個代碼塊加鎖，並且以synchronized(obj)的方式，表明該代碼塊內的obj對象是線程同步的。這個做法使得代碼靈活性大大加強，縮小同步代碼塊的范圍，並且可以在不同的函數體和類內進行同步，唯一遺憾的是實現起來比較復雜，容易產生一些問題

而wait()和notify()，必須在synchronized鎖的代碼塊內執行，否則系統將會報錯。
有了以上基礎，就可以很容易的創建後台線程了

Private Runnable backgroundRunnable = new Runnable () {
@Override
public void run() {
if(isFinish){
//.....
break;
}
for(;;){
synchronized(this){
//....寫耗時過程
wait();
}
}
}
}

UI線程中，就是一般的創建線程過程了
Thread backgroundThread = new Thread (backgroundRunnable);
backgroundThread.start();
這樣，在後台線程中會不斷的循環，當執行完一次過程以後就會wait()休眠。然後在OnTouchListener或者OnClickListener內相應的位置執行
synchronized(backgroundRunnable){
backgroundRunnable.notify();
}
當用戶觸摸屏幕產生一個event的時候，線程就會被喚醒，執行下一次循環。
最後，還是內存安全問題，必須復寫Activity中的OnDestory()方法，將標志量isFinish設為false，並且backgroundThread .stop()

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

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

1、第一種方式：使用Thread不帶參數的構造方法，並重寫run()方法<pre t="code" l="as3">new Thread(){

public void run(){
//在run方法中調用需要執行的代碼，完成後發送消息與主線程交互
Message msg=new Message();
msg.what=110;
handler.sengMessage();
}

}.start();2、第二種方式：使用Thread帶參數的構造方法，並重寫Runable()中的run方法<pre t="code" l="java">new Thread(new Runable(){

public void run(){
//在run方法中調用需要執行的代碼，完成後發送消息與主線程交互
Message msg=new Message();
msg.what=110;
handler.sengMessage();

}).start();3、在UI線程中接收Thread子線程發送的消息，刷新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：線程跳轉到另一個activity時，新activity不能創建線程

這個問題只需要了解Activity的啟動模擬即可。
Activity啟動模式有4種，分別為standard、singleTop、singleTask、singleInstance。

1.standard 默認模式，可以不用寫配置。在這個模式下，都會默認創建一個新的實例。因此，在這種模式下，可以有多個相同的實例，也允許多個相同Activity疊加。

2.singleTop 可以有多個實例，但是不允許多個相同Activity疊加。即，如果Activity在棧頂的時候，啟動相同的Activity，不會創建新的實例，而會調用其onNewIntent方法。
3.singleTask 只有一個實例。在同一個應用程序中啟動他的時候，若Activity不存在，則會在當前task創建一個新的實例，若存在，則會把task中在其之上的其它Activity destory掉並調用它的onNewIntent方法。
3.singleInstance只有一個實例，並且這個實例獨立運行在一個task中，這個task只有這個實例，不允許有別的Activity存在。

『捌』 android創建子線程

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