androidhandler非同步

A. Android的handler機制的原理

Android的handler機制的原理分為非同步通信准備，消息發送，消息循環，消息處理。

1、非同步通信准備

在主線程中創建處理器對象(Looper)、消息隊列對象(Message Queue)和Handler對象。

2、消息入隊

工作線程通過Handler發送消息(Message) 到消息隊列(Message Queue)中。

3、消息循環

消息出隊: Looper循環取出消息隊列(Message Queue) 中的的消息(Message)。

消息分發: Looper將取出的消息 (Message) 發送給創建該消息的處理者(Handler)。

4、消息處理

處理者(Handler) 接收處理器(Looper) 發送過來的消息(Message)，根據消息(Message) 進行U操作。

handler的作用

handler是android線程之間的消息機制，主要的作用是將一個任務切換到指定的線程中去執行，（准確的說是切換到構成handler的looper所在的線程中去出處理）android系統中的一個例子就是主線程中的所有操作都是通過主線程中的handler去處理的。

Handler的運行需要底層的 messagequeue和 looper做支撐。

B. Android開發之handlerhandler真的是重新啟動一個線程嗎

不是。

Handler非同步操作——是這樣的，new一個線程（子線程，這是手動new的，不是Handler new的），然後子線程中我們又想進行UI操作，這就需要Handler非同步操作，Handler給隊列中發送消息，然後UI線程提取，然後調用handleMessage....

可以去看一下郭神的CSDN博客，寫得很詳細的~~

//http://blog.csdn.net/guolin_blog/article/details/9991569

C. android handler和非同步任務有什麼區別

其實handler與非同步任務沒有可比性，您的基礎還需要加強。下面這篇csdn的博客中有handler的詳細介紹，
http://blog.csdn.net/androidwuyou/article/details/52601498

AsyncTask實現的原理和適用的優缺點
AsyncTask,是android提供的輕量級的非同步類,可以直接繼承AsyncTask,在類中實現非同步操作,並提供介面反饋當前非同步執行的程度(可以通過介面實現UI進度更新),最後反饋執行的結果給UI主線程.
使用的優點:
簡單,快捷
過程可控
使用的缺點:
在使用多個非同步操作和並需要進行Ui變更時,就變得復雜起來.

Handler非同步實現的原理和適用的優缺點
在Handler 非同步實現時,涉及到 Handler, Looper, Message,Thread四個對象，實現非同步的流程是主線程啟動Thread（子線程）運行並生成Message-Looper獲取Message並傳遞給HandlerHandler逐個獲取Looper中的Message，並進行UI變更。
使用的優點：
結構清晰，功能定義明確
對於多個後台任務時，簡單，清晰
使用的缺點：
在單個後台非同步處理時，顯得代碼過多，結構過於復雜（相對性）

AsyncTask介紹

Android的AsyncTask比Handler更輕量級一些（只是代碼上輕量一些，而實際上要比handler更耗資源），適用於簡單的非同步處理。
首先明確Android之所以有Handler和AsyncTask，都是為了不阻塞主線程（UI線程），且UI的更新只能在主線程中完成，因此非同步處理是不可避免的。

Android為了降低這個開發難度，提供了AsyncTask。AsyncTask就是一個封裝過的後台任務類，顧名思義就是非同步任務。
AsyncTask直接繼承於Object類，位置為android.os.AsyncTask。要使用AsyncTask工作我們要提供三個泛型參數，並重載幾個方法(至少重載一個)。

AsyncTask定義了三種泛型類型 Params，Progress和Result。
Params 啟動任務執行的輸入參數，比如HTTP請求的URL。
Progress 後台任務執行的百分比。
Result 後台執行任務最終返回的結果，比如String。
使用過AsyncTask 的同學都知道一個非同步載入數據最少要重寫以下這兩個方法：
doInBackground(Params…) 後台執行，比較耗時的操作都可以放在這里。注意這里不能直接操作UI。此方法在後台線程執行，完成任務的主要工作，通常需要較長的時間。在執行過程中可以調用publicProgress(Progress…)來更新任務的進度。
onPostExecute(Result) 相當於Handler 處理UI的方式，在這裡面可以使用在doInBackground 得到的結果處理操作UI。 此方法在主線程執行，任務執行的結果作為此方法的參數返回
有必要的話你還得重寫以下這三個方法，但不是必須的：
onProgressUpdate(Progress…) 可以使用進度條增加用戶體驗度。 此方法在主線程執行，用於顯示任務執行的進度。
onPreExecute() 這里是最終用戶調用Excute時的介面，當任務執行之前開始調用此方法，可以在這里顯示進度對話框。
onCancelled() 用戶調用取消時，要做的操作
使用AsyncTask類，以下是幾條必須遵守的准則：
Task的實例必須在UI thread中創建；
execute方法必須在UI thread中調用；
不要手動的調用onPreExecute(), onPostExecute(Result)，doInBackground(Params...), onProgressUpdate(Progress...)這幾個方法；
該task只能被執行一次，否則多次調用時將會出現異常；
Handler介紹
一、 Handler主要接受子線程發送的數據, 並用此數據配合主線程更新UI.
當應用程序啟動時，Android首先會開啟一個主線程, 主線程為管理界面中的UI控制項，進行事件分發,更新UI只能在主線程中更新，子線程中操作是危險的。這個時候，Handler就需要出來解決這個復雜的問題。由於Handler運行在主線程中(UI線程中),它與子線程可以通過Message對象來傳遞數據, 這個時候，Handler就承擔著接受子線程傳過來的(子線程用sedMessage()方法傳遞)Message對象(裡麵包含數據), 把這些消息放入主線程隊列中，配合主線程進行更新UI。
二、Handler的特點
Handler可以分發Message對象和Runnable對象到主線程中, 每個Handler實例,都會綁定到創建他的線程中,
它有兩個作用:
(1)安排消息或Runnable 在某個主線程中某個地方執行
(2)安排一個動作在不同的線程中執行
Handler中分發消息的一些方法
post(Runnable)
postAtTime(Runnable,long)
postDelayed(Runnable long)
sendEmptyMessage(int)
sendMessage(Message)
sendMessageAtTime(Message,long)
sendMessageDelayed(Message,long)
以上post類方法允許你排列一個Runnable對象到主線程隊列中,
sendMessage類方法, 允許你安排一個帶數據的Message對象到隊列中，等待更新.

D. [Android源碼分析] － 非同步通信Handler機制

一、問題：在Android啟動後會在新進程里創建一個主線程，也叫UI線程（ 非線程安全 ）這個線程主要負責監聽屏幕點擊事件與界面繪制。當Application需要進行耗時操作如網路請求等，如直接在主線程進行容易發生ANR錯誤。所以會創建子線程來執行耗時任務，當子線程執行完畢需要通知UI線程並修改界面時，不可以直接在子線程修改UI，怎麼辦？

解決方法：Message Queue機制可以實現子線程與UI線程的通信。

該機制包括Handler、Message Queue、Looper。Handler可以把消息/ Runnable對象 發給Looper，由它把消息放入所屬線程的消息隊列中，然後Looper又會自動把消息隊列里的消息/Runnable對象 廣播 到所屬線程里的Handler，由Handler處理接收到的消息或Runnable對象。

1、Handler

每次創建Handler對象時，它會自動綁定到創建它的線程上。如果是主線程則默認包含一個Message Queue，否則需要自己創建一個消息隊列來存儲。

Handler是多個線程通信的信使。比如在線程A中創建AHandler，給它綁定一個ALooper，同時創建屬於A的消息隊列AMessageQueue。然後在線程B中使用AHandler發送消息給ALooper，ALooper會把消息存入到AMessageQueue，然後再把AMessageQueue廣播給A線程里的AHandler，它接收到消息會進行處理。從而實現通信。

2、Message Queue

在主線程里默認包含了一個消息隊列不需要手動創建。在子線程里，使用Looper.prepare()方法後，會先檢查子線程是否已有一個looper對象，如果有則無法創建，因為每個線程只能擁有一個消息隊列。沒有的話就為子線程創建一個消息隊列。

Handler類包含Looper指針和MessageQueue指針，而Looper里包含實際MessageQueue與當前線程指針。

下面分別就UI線程和worker線程講解handler創建過程：

首先，創建handler時，會自動檢查當前線程是否包含looper對象，如果包含，則將handler內的消息隊列指向looper內部的消息隊列，否則，拋出異常請求執行looper.prepare()方法。

 － 在 UI線程 中，系統自動創建了Looper 對象，所以，直接new一個handler即可使用該機制；

－ 在 worker線程 中，如果直接創建handler會拋出運行時異常－即通過查『線程－value』映射表發現當前線程無looper對象。所以需要先調用Looper.prepare()方法。在prepare方法里，利用ThreadLocal<Looper>對象為當前線程創建一個Looper（利用了一個Values類，即一個Map映射表，專為thread存儲value，此處為當前thread存儲一個looper對象）。然後繼續創建handler， 讓handler內部的消息隊列指向該looper的消息隊列（這個很重要，讓handler指向looper里的消息隊列，即二者共享同一個消息隊列，然後handler向這個消息隊列發送消息，looper從這個消息隊列獲取消息） 。然後looper循環消息隊列即可。當獲取到message消息，會找出message對象里的target，即原始發送handler，從而回調handler的handleMessage() 方法進行處理。

 － handler與looper共享消息隊列 ，所以handler發送消息只要入列，looper直接取消息即可。

 － 線程與looper映射表 ：一個線程最多可以映射一個looper對象。通過查表可知當前線程是否包含looper，如果已經包含則不再創建新looper。

5、基於這樣的機制是怎樣實現線程隔離的，即在線程中通信呢。 

核心在於 每一個線程擁有自己的handler、message queue、looper體系 。而 每個線程的Handler是公開 的。B線程可以調用A線程的handler發送消息到A的共享消息隊列去，然後A的looper會自動從共享消息隊列取出消息進行處理。反之一樣。

二、上面是基於子線程中利用主線程提供的Handler發送消息出去，然後主線程的Looper從消息隊列中獲取並處理。那麼還有另外兩種情況：

1、主線程發送消息到子線程中；

採用的方法和前面類似。要在子線程中實例化AHandler並設定處理消息的方法，同時由於子線程沒有消息隊列和Looper的輪詢，所以要加上Looper.prepare(),Looper.loop()分別創建消息隊列和開啟輪詢。然後在主線程中使用該AHandler去發送消息即可。

2、子線程A與子線程B之間的通信。

1、 Handler為什麼能夠實現不同線程的通信？核心點在哪？

不同線程之間，每個線程擁有自己的Handler、消息隊列和Looper。Handler是公共的，線程可以通過使用目標線程的Handler對象來發送消息，這個消息會自動發送到所屬線程的消息隊列中去，線程自帶的Looper對象會不斷循環從裡面取出消息並把消息發送給Handler，回調自身Handler的handlerMessage方法，從而實現了消息的線程間傳遞。

2、 Handler的核心是一種事件激活式（類似傳遞一個中斷）的還是主要是用於傳遞大量數據的？重點在Message的內容，偏向於數據傳輸還是事件傳輸。

目前的理解，它所依賴的是消息隊列，發送的自然是消息，即類似事件中斷。

0、 Android消息處理機制(Handler、Looper、MessageQueue與Message)

1、 Handler、Looper源碼閱讀

2、 Android非同步消息處理機制完全解析，帶你從源碼的角度徹底理解

謝謝！

wingjay


E. Android面試 Handler機制

Handler就是解決線程與線程間的通信。
當我們在子線程處理耗時操作，耗時操作完成後我們需要更新UI的時候，這就是需要使用Handler來處理了，因為子線程不能更 新UI，Handler能讓我們容易的把任務切換回來它所在的線程。
消息處理機制本質：一個線程開啟循環模式持續監聽並依次處理其他線程給它發的消息。

一個線程可以有多個Handler，通過new Handler的方式創建。

一個線程只能有一個Looper，通過Looper.perpare方法會創建一個Looper保存在ThreadLocal中，每個線程都有一個LocalThreadMap，會將Looper保存在對應線程中的LocalThreadMap，key為ThreadLocal，value為Looper。

內部類持有外部類的對象，handler持有activity的對象，當頁面activity關閉時，handler還在發送消息，handler持有activity的對象，導致handler不能及時被回收，所以造成內存泄漏。

因為當handler發送消息時，會有耗時操作，並且會利用線程中的looper和messageQueue進行消息發送，looper和messageQueue的生命周期是很長的，和application一樣，所以handler不容易被銷毀，所以造成內存泄漏。

解決方案有：

可以在子線程中創建Handler，我們需要調用Looper.perpare和Looper.loop方法。或者通過獲取主線程的looper來創建Handler。

應該調用Looper的quit方法，因為可以將looper中的messageQueue里的message都移除掉，並且將內存釋放。

通過synchronized鎖機制保證線程安全。

Message.obtain來創建Message。這樣會復用之前的Message的內存，不會頻繁的創建對象，導致內存抖動。

點擊按鈕的時候會發送消息到Handler，但是為了保證優先執行，會加一個標記非同步，同時會發送一個target為null的消息，這樣在使用消息隊列的next獲取消息的時候，如果發現消息的target為null，那麼會遍歷消息隊列將有非同步標記的消息獲取出來優先執行，執行完之後會將target為null的消息移除。(同步屏障)

更多內容戳這里（整理好的各種文集）

F. Android面試必問handler機制淺析

Handler是Android中的非同步消息處理機制。當發送一個消息之後，這個消息是進入一個消息隊列（MessageQueue），在消息隊列中通過Looper去循環的獲取隊列中的消息，然後將消息分派給對應的處理者進行處理。

Message：存儲需要處理操作的信息

MessageQueue：先進先出，存儲handler發送過來的消息

Looper：循環器，它是消息隊列和handler的通信媒介，1：循環的取出消息隊列中的消息；2：將取出的消息發送給對應的處理者

Handler：主線程和子線程的通信媒介，1:添加消息到消息隊列； 2:處理循環器分派過來的消息

在handler機制中，Looper.loop方法會不斷循環獲取Message， 其中的消息的獲取是通過調用MessageQueue的next()方法獲取的，而該方法會調用nativePollOnce()方法 ，這是一個native方法。底層的實現涉及到Linux pipe/epoll機制,nativePollOnce()被阻塞時,主線程會釋放CPU資源,進入休眠狀態. 直到下個消息到達或者有事務發生,會通過pipe管道寫端寫入數據來喚醒looper工作。

Android6.0及以前的版本使用管道與epoll來完成Looper的休眠與喚醒的

Android6.0及以後的版本使用eventfd與epoll來完成Looper的休眠與喚醒的

如果不處理的話，會阻塞線程，處理方案是調用Looper的quit()（清空所有的延遲和非延遲的消息）和quitSafely()（只清空延遲消息）； 這個方法會調用MessageQueue的quit()方法，清空所有的Message，並調用nativeWake()方法喚醒之前被阻塞的nativePollOnce()，使得方法next()方法中的for循環繼續執行，接下來發現Message為null後就會結束循環，Looper結束。如此便可以釋放內存和線程

同進程線程間內存共享，通過handler通信，消息的內容是不需要從一個線程拷貝到另一個線程，因為兩個線程間可使用的內存是同一個區域。（注意：線程私有區域ThreadLocal）

管道的作用就是當一個線程准備好Message，並放入消息池，這時需要通知了一個線程B去處理這個消息。線程A向管道的寫端寫入數據，管道有數據便會喚醒線程B去處理消息。管道的作用是用於通知另一個線程的，這便是最核心的作用。

從內存角度，通信過程中binder涉及到一次內存拷貝，handler機制中的Message根本不需要拷貝，本身就是在同一片內存。

從CPU角度，為了Binder通信底層驅動還需要創建一個binder線程池，每次通信涉及binder線程的創建和內存的分配等比較浪費CPU資源

原因：handler發送的消息在當前handler的消息隊列中，如果此時activity被finish掉了，那麼消息隊列的消息依舊由handler進行處理，若此時handler申明為內存類（非靜態內部類），內部類持有外部類的實例引用，這樣在GC垃圾回收時發現Activity還有其他引用存在，因而就不會去回首這個Activity，進而導致Activity泄漏。

方法：使用靜態內部類，並且使用WeakReference包裹外部類的對象。首先靜態內部類不持有外部類的引用，使用靜態的handler不會導致activity的泄漏，handler定義static的同時，還要用WeakReference包裹外部類的對象。

G. Android Handler那些事兒，消息屏障IdelHandlerANR

Handler 是Android SDK中用來處理非同步消息的核心類，子線程可以通過handler來通知主線程進行ui更新。

備註：本文源碼截圖 基於Android sdk 28

Handler機制 消息發送主要流程如圖

應用程序啟動後，zygote fork一個應用進程後，和普通java程序一樣，程序會首先執行ActivityThread中的main函數。在main函數中，程序首先會創建Looper對象並綁定到主線程中，然後開啟loop循環。（ps:主線程loop循環不能退出）

在prepareMainLooper方法中，最終會創建Looper，MessageQueue對象 以及創建native層MessageQueue對象。

使用Handler.sendMessageXXX或這 postDedayXXX發送消息後，最終會調用到SendMessageAtTime方法中。

然後調用MessageQueue.enqueueMessage將消息存到消息隊列中。

存入消息後，然後通過調用native方法 喚醒主線程進行消息處理。

當應用程序啟動，做完一些必要工作之後，便會開啟Loop循環，除非系統異常，否則該循環不會停止。loop循環中，主要做兩件事，第一，從消息隊列中取消息。第二，進行消息分發處理。

MessageQueue.next() 方法 通過調用 native方法 nativePollOnce(ptr, nextPollTimeoutMillis)實現無消息處理時，進入阻塞的功能。
當nextPollTimeoutMillis 值為0時，該方法會立刻返回；
當nextPollTimeoutMillis 值為-1時，該方法會無限阻塞，直到被喚醒；
當nextPollTimeoutMillis 值大於0時，該方法會將該值設置為超時時間，阻塞到達一定時間後，返回；

在loop循環中 ，通過調用 msg.target.dispatchMessage(msg) 進行消息的分發處理

使用當前線程的MessageQueue.addIdleHandler方法可以在消息隊列中添加一個IdelHandler。

當MessageQueue 阻塞時，即當前線程空閑時，會回調IdleHandler中的方法；

當IdelHandler介面返回false時，表示該IdelHandler只執行一次，

a，延遲執行

例如，當啟動Activity時，需要延時執行一些操作，以免啟動過慢，我們常常使用以下方式延遲執行任務，但是在延遲時間上卻不好控制。

其實，這時候使用IdelHandler 會更優雅

b，批量任務，任務密集，且只關注最終結果

例如，在開發一個IM類型的界面時，通常情況下，每次收到一個IM消息時，都會刷新一次界面，但是當短時間內， 收到多條消息時，就會刷新多次界面，容易造成卡頓，影響性能，此時就可以使用一個工作線程監聽IM消息，在通過添加IdelHandler的方式通知界面刷新，避免短時間內多次刷新界面情況的發生。

在Android的消息機制中，其實有三種消息: 普通消息、非同步消息及消息屏障。

消息屏障 也是一種消息，但是它的target為 null。可以通過MessageQueue中的postSyncBarrier方法發送一個消息屏障（該方法為私有，需要反射調用）。

在消息循環中，如果第一條消息就是屏障消息，就往後遍歷，看看有沒有非同步消息:
如果沒有，則無限休眠，等待被喚醒
如果有，就看離這個消息被觸發時間還有多久，設置一個超時時間，繼續休眠

非同步消息 和普通消息一樣，只不過它被設置setAsynchronous 為true。有了這個標志位，消息機制會對它有些特別的處理，我們稍後說。

所以 消息屏障和非同步消息的作用 很明顯，在設置消息屏障後，非同步消息具有優先處理的權利。

這時候我們回顧將消息添加到消息隊列中時，可以發現，其實並不是每一次添加消息時，都會喚醒線程。
當該消息插入到隊列頭時，會喚醒該線程；
當該消息沒有插入到隊列頭，但隊列頭是屏障，且該消息是隊列中 靠前的一個非同步消息，則會喚醒線程，執行該消息；

調用MessageQueue.removeSyncBarrier 方法可以移除指定的消息屏障

ANR 即 Application Not Response， 是系統進程對應用行為的一種監控，如果應用程序沒有在規定時間內完成任務的話，就會引起ANR。

ANR類型

Service Timeout : 前台服務20s, 後台服務200s

BroadcastQueue Timeout : 前台廣播 10s，後台廣播60s

ContentPrivider Timeout : 10s

InputDispatching Timeout : 5s

比如，在啟動一個服務時， AMS端通過應用進程的Binder對象創建Service, 在scheleCreateService()方法中 會調用到當前service的onCreate()生命周期函數；

bumpServiceExecutingLocked()方法內部實際上會調用到scheleServiceTimeoutLocked()方法，發送一個ActivityManagerService.SERVICE_TIMEOUT_MSG類型消息到AMS工作線程中。

消息的延時時間，如果是前台服務，延時20s, 如果是後台服務，延時200s;

如果Service的創建 工作在 上訴消息的延時時間內完成，則會移除該消息，

否則，在Handler正常收到這個消息後，就會進行服務超時處理，即彈出ANR對話框。

復雜情況下，可能會頻繁調用sendMessage 往消息隊列中，添加消息，導致消息積壓，造成卡頓，

1，重復消息過濾

頻繁發送同類型消息時，有可能隊列中之前的消息還沒有處理，又發了一條相同類型的消息，更新之前的數據，這時候，可以採用移除前一個消息的方法，優化消息隊列。

2，互斥消息取消

在發送消息時，優先將消息隊列中還未處理的信息已經過時的消息 移除，優化隊列

3，隊列優化-復用消息

創建消息時，優先採用之前回收的消息，避免重復創建對象，引起GC

完~
（如果錯誤或不足，望指出， 大家共同進步）

H. Android-Handler同步屏障

消息機制的同步屏障，其實就是阻礙同步消息，只讓非同步消息通過。而開啟同步屏障的方法就是調用下面的方法：

源碼如下：

在這里可以看到，Message對象初始化的時候並沒有給target賦值，因此target==null的來源就找得到了。這樣就可以插入一條target==null的消息，這個消息就是一個同步屏障。
那麼開啟消息屏障後，所謂的非同步消息又是如何處理的呢？
消息的最終處理其實都是在消息輪詢器Looper#loop()中，而loop()循環中會調用MessageQueue#next()從消息隊列中進行取消息。

從上面的MessageQueue.next方法可以看出，當消息隊列開啟同步屏障的時候（即標識為msg.target==null），消息機制在處理消息的時候，會優先處理非同步消息。這樣，同步屏障就起到了一種過濾和優先順序的作用。

如果上圖所示，在消息隊列中有同步消息和非同步消息（黃色部分）以及一道牆（同步屏障--紅色部分）。有了同步屏障的存在，msg_2和msg_M這兩個非同步消息可以被優先處理，而後面的msg_3等同步消息則不會被處理。那麼這些同步消息什麼時候可以被處理呢？就需要先移除這個同步屏障，即調用MessageQueue#removeSyncBarrier()

同步屏障一般在日常開發中比較少用，而在系統源碼中就有使用。Android系統中的UI更新相關的消息即為非同步消息，需要優先處理。
16ms左右刷新UI，而是60hz的屏幕，即1s刷新60次。
在Android中什麼是非同步消息？即給：

比如，在View更新時，draw、requestLayout、invalidate等很多地方都調用了。ViewRootImpl#scheleTraversals()。

在這里，mChoreographer.postCallback最終會執行到了Choreographer#postCallbackDelayedInternal()

可以看到，這里就開啟了同步屏障，並且發送了非同步消息。由於UI相關的消息是優先順序最高的，這樣系統就會優先處理這些非同步消息。
最後，當然要移除同步屏障的時候，調用ViewRootImpl#unscheleTraversals

在ViewRootImpl中的doTraversal()方法中也會移除同步屏障，這里移除是因為requestLayout或者invalidate的時候，刷新之後，在doTraversal()中就會移除同步屏障，因為此時消息已經發送並且處理了。

I. android中handler如何使用

Handler在Android中主要是負責發送和處理消息。它的主要用途大致是下面兩個:

1)按計劃發送消息或執行某個Runnanble;

2)從其他線程中發送來的消息放入消息隊列中,避免線程沖突(常見於更新UI線程)

學寫一下,在UI線程中,系統已經有一個Activity來處理了,你可以再起若干個Handler來處理。在實例化Handler的時候,只要有Handler的指針,任何線程也都可以sendMessage。

Handler對於Message的處理是非同步處理的。一個Looper 只有處理完一條Message才會讀取下一條,所以消息的處理是阻塞形式的(handleMessage()方法里不應該有耗時操作,可以將耗時操作放在其他線程執行,操作完後發送Message(通過sendMessges方法),然後由handleMessage()更新UI)。

根據對視頻的學習寫了一個通過Button控制項啟動進度條(類似於下載等操作)的程序,簡單介紹一下,有兩個Button控制項,一個是開始,點擊之後會顯示一個進度條以每次十分之一的進度進行(一開始是隱藏的),另一個是停止,可以中斷進度。

java代碼:

1 package zzl.handleactivity;

2

3 import android.app.Activity;

4 import android.os.Bundle;

5 import android.os.Handler;

6 import android.os.Message;

7 import android.view.Gravity;

8 import android.view.View;

9 import android.view.View.OnClickListener;

10 import android.widget.Button;

11 import android.widget.ProgressBar;

12 import android.widget.Toast;

13

14 public class Handler_01 extends Activity {

15

16 //聲明變數

17 private Button startButton=null;

18 private Button endButton=null;

19 private ProgressBar firstBar=null;

20 private Toast toast=null;

21 @Override

22 protected void onCreate(Bundle savedInstanceState) {

23 super.onCreate(savedInstanceState);

24 setContentView(R.layout.main);

25

26 //根據ID獲取對象

27 startButton =(Button)findViewById(R.id.startButton);

28 endButton=(Button)findViewById(R.id.endButton);

29 firstBar=(ProgressBar)findViewById(R.id.firstBar);

30 //給對象設置動作監聽器

31 startButton.setOnClickListener(new StartButtonListener());

32 endButton.setOnClickListener(new EndButtonListener());

33 }

34

35 class StartButtonListener implements OnClickListener{

36

37 @Override

38 public void onClick(View v) {

39 // TODO Auto-generated method stub

40 //一開始執行,加入到消息隊列,不延遲,

41 //然後馬上執行run方法

42 firstBar.setVisibility(View.VISIBLE);

43 firstBar.setMax(100);

44 handler.post(upRunnable);

45 toast=Toast.makeText(Handler_01.this, "運行開始", Toast.LENGTH_SHORT);

46 toast.setGravity(Gravity.CENTER, 0, 0);

47 toast.show();

48 }

49 }

50 class EndButtonListener implements OnClickListener{

51

52 @Override

53 public void onClick(View v) {

54 // TODO Auto-generated method stub

55 //停止

56 handler.removeCallbacks(upRunnable);

57 System.out.println("It's time to stop...");

58 }

59 }

60

61 //創建handler對象,在調用post方法

62 //非同步消息處理:將下載或者處理大數據等等單獨放到另一個線程

63 //更好的用戶體驗

64 Handler handler=new Handler(){

65

66 @Override

67 public void handleMessage(Message msg){

68 firstBar.setProgress(msg.arg1);

69 firstBar.setSecondaryProgress(msg.arg1+10);

70 //handler.post(upRunnable);

71 if(msg.arg1<=100) {

72 handler.post(upRunnable); //將要執行的線程放入到隊列當中

73 }else {

74 handler.removeCallbacks(upRunnable);

75 }

76 }

77 };

78

79 //聲明線程類:實現Runnable的介面

80 Runnable upRunnable=new Runnable() {

81

82 int i=0;

83 @Override

84 public void run() {//程序的運行狀態

85 // TODO Auto-generated method stub

86 //postDelayed方法:把線程對象加入到消息隊列中

87 // 隔2000ms(延遲)

88 System.out.println("It's time to start...");

89 i=i+10;

90 //獲取Message消息對象

91 Message msg=handler.obtainMessage();

92 //將msg對象的arg1(還有arg2)對象的值設置

93 //使用這兩個變數傳遞消息優點:系統消耗性能較少

94 msg.arg1=i;

95 try{

96 //設置當前顯示睡眠1秒

97 Thread.sleep(1000);

98 }catch(InterruptedException e){

99 e.printStackTrace();

100 }

101 //將msg對象加入到消息隊列當中

102 handler.sendMessage(msg);

103 if(i==100){//當值滿足時,將線程對象從handle中剔除

104 handler.removeCallbacks(upRunnable);

105 firstBar.setVisibility(View.GONE);

106 //臨時彈出

107

108 toast=Toast.makeText(Handler_01.this, "運行結束", Toast.LENGTH_SHORT);

109 toast.setGravity(Gravity.CENTER, 0, 0);

110 toast.show();

111 }

112 }

113 };

114 }

main.xml

1 <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

2 xmlns:tools="http://schemas.android.com/tools"

3 android:orientation="vertical"

4 android:layout_width="match_parent"

5 android:layout_height="match_parent"

6 tools:context=".Handler_01" >

7

8 <ProgressBar

9 android:id="@+id/firstBar"

10 style="?android:attr/progressBarStyleHorizontal"

11 android:layout_width="200dp"

12 android:layout_height="wrap_content"

13 android:visibility="gone"/>

14

15 <Button

16 android:id="@+id/startButton"

17 android:layout_width="wrap_content"

18 android:layout_height="wrap_content"

19 android:text="@string/start" />

20

21 <Button

22 android:id="@+id/endButton"

23 android:layout_width="wrap_content"

24 android:layout_height="wrap_content"

25 android:text="@string/end" />

26

27 </LinearLayout>

總結:

1)當點擊開始或者運行結束的時候,都會通過調用Toas彈出臨時窗口,Toast.makeText(Handler_01.this, "運行結束", Toast.LENGTH_SHORT),這一句一開始總是執行出錯,原因在於必須調用它的show方法才可以顯示出來,還可以通過設置它的位置來顯示;

2)在xml中 android:text="@string/end",則需要在layout下的string文件中敲寫相應的代碼

3)原本代碼有一些瑕疵,就是沒有下面這一段代碼:

1 if(msg.arg1<=100) {

2 handler.post(upRunnable); //將要執行的線程放入到隊列當中

3 }else {

4 handler.removeCallbacks(upRunnable);

5 }

這樣就導致了upRunnable的run方法出現了死循環,這樣,雖然程序UI本身沒有問題,但是內部卻又很大的缺陷

這是因為

1 if(i==100){//當值滿足時,將線程對象從handle中剔除

2 handler.removeCallbacks(upRunnable);

3 firstBar.setVisibility(View.GONE);

4 toast=Toast.makeText(Handler_01.this, "運行結束", Toast.LENGTH_SHORT);

5 toast.setGravity(Gravity.CENTER, 0, 0);

6 toast.show();

7 }

這一段代碼看似是把upRunnable線程從線程對象隊列中移除,但是再次之前又前執行了handler.sendMessage(msg);這句代碼

從而導致下面的代碼又被執行到

1 public void handleMessage(Message msg){

2 firstBar.setProgress(msg.arg1);

3 firstBar.setSecondaryProgress(msg.arg1+10);

4

5 }

這樣肯定會使upRunnable線程重新加入到線程對象隊列中,updateThread的run方法重復執行,這就導致了死循環。所以必須加上之前的那段代碼,通過判斷來控制循環終止。並且run方法中的if(i==100)的那段代碼也是可以不用的,不過我是寫了一些其他代碼就懶得優化了,這是後話了。

4) 剛剛大家看到我們可以通過敲寫System.out.println在logcat中顯示,一開始eclipse編譯器中是沒有,這是如何顯示出來的?

大家可以再window的show view中找到logCat(deprecated)通過下圖中綠色的「+」添加出來

然後顯示內容的時候,選擇右上角「V D I W E 」的I就可以比較清晰的顯示出來了,當然你也可以選擇另外一個logCat來顯示,方法類似。

5)實際上,Handler在默認情況下,和調用它的Activity是處於同一個線程的。 上述Handler的使用示例中,雖然聲明了線程對象,但是在實際調用當中它並沒有調用線程的start()方法,而是直接調用當前線程的run()方法。

如果要實現調用另一個新的線程,只要注釋post方法,然後加上這樣兩段代碼即可: Thread t = new Thread(r); t.start();

J. 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線程）+任務的等待隊列的形式，優點是不會有堵塞，減少了對性能的消耗，缺點是不能同時進行多個任務的處理，需要等待進行處理。處理效率低，可以當成一個輕量級的線程池來用）