Android消息处理机制
Google參考了Windows的消息處理機(jī)制，在Android系統(tǒng)中實現(xiàn)了一套類似的消息處理機(jī)制。學(xué)習(xí)Android的消息處理機(jī)制，有幾個概念（類）必須了解：
1.?????? Message
消息，理解為線程間通訊的數(shù)據(jù)單元。例如后臺線程在處理數(shù)據(jù)完畢后需要更新UI，則可發(fā)送一條包含更新信息的Message給UI線程。
2.?????? Message Queue
消息隊列，用來存放通過Handler發(fā)布的消息，按照先進(jìn)先出執(zhí)行。
3.?????? Handler
Handler是Message的主要處理者，負(fù)責(zé)將Message添加到消息隊列以及對消息隊列中的Message進(jìn)行處理。
4.?????? Looper
循環(huán)器，扮演Message Queue和Handler之間橋梁的角色，循環(huán)取出Message Queue里面的Message，并交付給相應(yīng)的Handler進(jìn)行處理。
?
5．??? 線程
UI thread 通常就是main thread，而Android啟動程序時會替它建立一個Message Queue。
每一個線程里可含有一個Looper對象以及一個MessageQueue數(shù)據(jù)結(jié)構(gòu)。在你的應(yīng)用程序里，可以定義Handler的子類別來接收Looper所送出的消息。
?
運(yùn)行機(jī)理：
??????每個線程都可以并僅可以擁有一個Looper實例，消息隊列MessageQueue在Looper的構(gòu)造函數(shù)中被創(chuàng)建并且作為成員變量被保存，也就是說MessageQueue相對于線程也是唯一的。Android應(yīng)用在啟動的時候會默認(rèn)會為主線程創(chuàng)建一個Looper實例，并借助相關(guān)的Handler和Looper里面的MessageQueue完成對Activities、Services、Broadcase Receivers等的管理。而在子線程中，Looper需要通過顯式調(diào)用Looper. Prepare()方法進(jìn)行創(chuàng)建。Prepare方法通過ThreadLocal來保證Looper在線程內(nèi)的唯一性，如果Looper在線程內(nèi)已經(jīng)被創(chuàng)建并且嘗試再度創(chuàng)建"Only one Looper may be created per thread"異常將被拋出。
?
??????Handler在創(chuàng)建的時候可以指定Looper，這樣通過Handler的sendMessage()方法發(fā)送出去的消息就會添加到指定Looper里面的MessageQueue里面去。在不指定Looper的情況下，Handler綁定的是創(chuàng)建它的線程的Looper。如果這個線程的Looper不存在，程序?qū)伋?#34;Can't create handler inside thread that has not called Looper.prepare()"。
?
??????整個消息處理的大概流程是：1. 包裝Message對象（指定Handler、回調(diào)函數(shù)和攜帶數(shù)據(jù)等）；2. 通過Handler的sendMessage()等類似方法將Message發(fā)送出去；3. 在Handler的處理方法里面將Message添加到Handler綁定的Looper的MessageQueue；4. Looper的loop()方法通過循環(huán)不斷從MessageQueue里面提取Message進(jìn)行處理，并移除處理完畢的Message；5. 通過調(diào)用Message綁定的Handler對象的dispatchMessage()方法完成對消息的處理。
?
??????在dispatchMessage()方法里，如何處理Message則由用戶指定，三個判斷，優(yōu)先級從高到低：1. Message里面的Callback，一個實現(xiàn)了Runnable接口的對象，其中run函數(shù)做處理工作；2. Handler里面mCallback指向的一個實現(xiàn)了Callback接口的對象，由其handleMessage進(jìn)行處理；3. 處理消息Handler對象對應(yīng)的類繼承并實現(xiàn)了其中handleMessage函數(shù)，通過這個實現(xiàn)的handleMessage函數(shù)處理消息。???
?
?
Android的消息機(jī)制(一)
?
android 有一種叫消息隊列的說法，這里我們可以這樣理解：假如一個隧道就是一個消息隊列，那么里面的每一部汽車就是一個一個消息，這里我們先忽略掉超車等種種因素，只那么先進(jìn)隧道的車將會先出，這個機(jī)制跟我們android 的消息機(jī)制是一樣的。
一、????角色描述
1.Looper:(相當(dāng)于隧道)一個線程可以產(chǎn)生一個Looper對象，由它來管理此線程里的Message Queue(車隊,消息隧道)。
2.Handler:你可以構(gòu)造Handler對象來與Looper溝通，以便push新消息到Message Queue里；或者接收Looper(從Message Queue取出)所送來的消息。
3. Message Queue(消息隊列):用來存放線程放入的消息。
4．線程：UI thread通常就是main thread，而Android啟動程序時會替它建立一個Message Queue。
每一個線程里可含有一個Looper對象以及一個MessageQueue數(shù)據(jù)結(jié)構(gòu)。在你的應(yīng)用程序里，可以定義Handler的子類別來接收Looper所送出的消息。
?
在你的Android程序里，新誕生一個線程，或執(zhí)行(Thread)時，并不會自動建立其Message Loop。
Android里并沒有Global的Message Queue數(shù)據(jù)結(jié)構(gòu)，例如，不同APK里的對象不能透過Massage Queue來交換訊息(Message)。
例如：線程A的Handler對象可以傳遞消息給別的線程，讓別的線程B或C等能送消息來給線程A(存于A的Message Queue里)。
線程A的Message Queue里的訊息，只有線程A所屬的對象可以處理。
使用Looper.myLooper可以取得當(dāng)前線程的Looper對象。
使用mHandler = new EevntHandler(Looper.myLooper());可用來構(gòu)造當(dāng)前線程的Handler對象；其中，EevntHandler是自已實現(xiàn)的Handler的子類別。
使用mHandler = new EevntHandler(Looper.getMainLooper());可誕生用來處理main線程的Handler對象；其中，EevntHandler是自已實現(xiàn)的Handler的子類別。
?
這樣描述可能太抽像，下面舉幾個實際的例子來說明：
二、????舉例
1.??同線程內(nèi)不同組件間的消息傳遞
Looper類用來管理特定線程內(nèi)對象之間的消息交換(Message Exchange)。你的應(yīng)用程序可以產(chǎn)生許多個線程。而一個線程可以有許多個組件，這些組件之間常常需要互相交換訊息。如果有這種需要，您可以替線程構(gòu)造一個Looper對象，來擔(dān)任訊息交換的管理工作。Looper對象會建立一個MessageQueue數(shù)據(jù)結(jié)構(gòu)來存放各對象傳來的消息(包括UI事件或System事件等)。如下圖：
?
每一個線程里可含有一個Looper對象以及一個MessageQueue數(shù)據(jù)結(jié)構(gòu)。在你的應(yīng)用程序里，可以定義Handler的子類別來接收Looper所送出的消息。
同線程不同組件之間的消息傳遞：
publicclass?Activity1extends?Activityimplements?OnClickListener{
?????? Buttonbutton?=null;
?????? TextViewtext?=null;
??????@Override
??????protectedvoid?onCreate(Bundle savedInstanceState) {
?????????????super.onCreate(savedInstanceState);
????????????? setContentView(R.layout.activity1);????????
?????????????button?= (Button)findViewById(R.id.btn);
?????????????button.setOnClickListener(this);
?????????????text?= (TextView)findViewById(R.id.content);
?????? }
??????publicvoid?onClick(View v) {
?????????????switch?(v.getId()) {
?????????????case?R.id.btn:
???????????????????? Looper looper = Looper.myLooper();//取得當(dāng)前線程里的looper
???????????????????? MyHandler mHandler =new?MyHandler(looper);//構(gòu)造一個handler使之可與looper通信
????????????????????//buton等組件可以由mHandler將消息傳給looper后,再放入messageQueue中,同時mHandler也可以接受來自looper消息
???????????????????? mHandler.removeMessages(0);
???????????????????? String msgStr ="主線程不同組件通信:消息來自button";
???????????????????? Message m = mHandler.obtainMessage(1, 1, 1, msgStr);//構(gòu)造要傳遞的消息
???????????????????? mHandler.sendMessage(m);//發(fā)送消息:系統(tǒng)會自動調(diào)用handleMessage方法來處理消息
????????????????????break;
?????????????? }????????????
?????? }?????
??????privateclass?MyHandlerextends?Handler{?????????????
?????????????public?MyHandler(Looper looper){
????????????????????super(looper);
????????????? }
?????????????@Override
?????????????publicvoid?handleMessage(Message msg) {//處理消息
????????????????????text.setText(msg.obj.toString());
????????????? }????????????
?????? }
}
?
說明：
此程序啟動時，當(dāng)前線程(即主線程, main thread)已誕生了一個Looper對象，并且有了一個MessageQueue數(shù)據(jù)結(jié)構(gòu)。
??? looper = Looper.myLooper ();?
調(diào)用Looper類別的靜態(tài)myLooper()函數(shù)，以取得目前線程里的Looper對象.
mHandler = new MyHandler (looper);
構(gòu)造一個MyHandler對象來與Looper溝通。Activity等對象可以藉由MyHandler對象來將消息傳給Looper，然后放入MessageQueue里；MyHandler對象也扮演Listener的角色，可接收Looper對象所送來的消息。
Message m = mHandler.obtainMessage(1, 1, 1, obj);
先構(gòu)造一個Message對象，并將數(shù)據(jù)存入對象里。
mHandler.sendMessage(m);
就透過mHandler對象而將消息m傳給Looper，然后放入MessageQueue里。
此時，Looper對象看到MessageQueue里有消息m，就將它廣播出去，mHandler對象接到此訊息時，會呼叫其handleMessage()函數(shù)來處理，于是輸出"This my message!"于畫面上，
Android消息處理機(jī)制(二)
角色綜述（回顧）:
?? (1)UI thread通常就是main thread，而Android啟動程序時會替它建立一個MessageQueue。
(2)當(dāng)然需要一個Looper對象，來管理該MessageQueue。
(3)我們可以構(gòu)造Handler對象來push新消息到Message Queue里；或者接收Looper(從Message Queue取出)所送來的消息。
(4)線程A的Handler對象可以傳遞給別的線程，讓別的線程B或C等能送訊息來給線程A(存于A的Message Queue里)。
(5)線程A的Message Queue里的消息，只有線程A所屬的對象可以處理。
?
子線程傳遞消息給主線程
publicclass?Activity2extends?Activityimplements?OnClickListener{
?????? Buttonbutton?=null;
?????? TextViewtext?=null;
?????? MyHandlermHandler?=null;
?????? Threadthread?;
??????@Override
??????protectedvoid?onCreate(Bundle savedInstanceState) {
?????????????super.onCreate(savedInstanceState);
????????????? setContentView(R.layout.activity1);????????
?????????????button?= (Button)findViewById(R.id.btn);
?????????????button.setOnClickListener(this);
?????????????text?= (TextView)findViewById(R.id.content);
?????? }
??????publicvoid?onClick(View v) {
?????????????switch?(v.getId()) {
?????????????case?R.id.btn:
????????????????????thread?=new?MyThread();
????????????????????thread.start();
????????????????????break;
????????????? }????????????
?????? }?????
??????privateclass?MyHandlerextends?Handler{?????????????
?????????????public?MyHandler(Looper looper){
????????????????????super(looper);
????????????? }
?????????????@Override
?????????????publicvoid?handleMessage(Message msg) {//處理消息
????????????????????text.setText(msg.obj.toString());
????????????? }????????????
?????? }
??????privateclass?MyThreadextends?Thread{
?????????????@Override
?????????????publicvoid?run() {
???????????????????? Looper curLooper = Looper.myLooper();
???????????????????? Looper mainLooper = Looper.getMainLooper();
???????????????????? String msg ;
????????????????????if(curLooper==null){
???????????????????????????mHandler?=new?MyHandler(mainLooper);
??????????????????????????? msg ="curLooper is null";
???????????????????? }else{
???????????????????????????mHandler?=new?MyHandler(curLooper);
??????????????????????????? msg ="This is curLooper";
???????????????????? }
????????????????????mHandler.removeMessages(0);
???????????????????? Message m =mHandler.obtainMessage(1, 1, 1, msg);
????????????????????mHandler.sendMessage(m);
????????????? }????????????
?????? }
}
說明：
Android會自動替主線程建立Message Queue。在這個子線程里并沒有建立Message Queue。所以，myLooper值為null，而mainLooper則指向主線程里的Looper。于是，執(zhí)行到：
mHandler = new MyHandler (mainLooper);
此mHandler屬于主線程。
?? mHandler.sendMessage(m);
就將m消息存入到主線程的Message Queue里。mainLooper看到Message Queue里有訊息，就會作出處理，于是由主線程執(zhí)行到mHandler的handleMessage()來處理消息。
用Android線程間通信的Message機(jī)制
在Android下面也有多線程的概念，在C/C++中，子線程可以是一個函數(shù)，一般都是一個帶有循環(huán)的函數(shù)，來處理某些數(shù)據(jù)，優(yōu)先線程只是一個復(fù)雜的運(yùn)算過程，所以可能不需要while循環(huán)，運(yùn)算完成，函數(shù)結(jié)束，線程就銷毀。對于那些需要控制的線程，一般我們都是和互斥鎖相互關(guān)聯(lián)，從而來控制線程的進(jìn)度，一般我們創(chuàng)建子線程，一種線程是很常見的，那就是帶有消息循環(huán)的線程。
消息循環(huán)是一個很有用的線程方式，曾經(jīng)自己用C在Linux下面實現(xiàn)一個消息循環(huán)的機(jī)制，往消息隊列里添加數(shù)據(jù)，然后異步的等待消息的返回。當(dāng)消息隊列為空的時候就會掛起線程，等待新的消息的加入。這是一個很通用的機(jī)制。
在Android，這里的線程分為有消息循環(huán)的線程和沒有消息循環(huán)的線程，有消息循環(huán)的線程一般都會有一個Looper，這個事android的新概念。我們的主線程（UI線程）就是一個消息循環(huán)的線程。針對這種消息循環(huán)的機(jī)制，我們引入一個新的機(jī)制Handle，我們有消息循環(huán)，就要往消息循環(huán)里面發(fā)送相應(yīng)的消息，自定義消息一般都會有自己對應(yīng)的處理，消息的發(fā)送和清除，消息的的處理，把這些都封裝在Handle里面，注意Handle只是針對那些有Looper的線程，不管是UI線程還是子線程，只要你有Looper，我就可以往你的消息隊列里面添加?xùn)|西，并做相應(yīng)的處理。
但是這里還有一點，就是只要是關(guān)于UI相關(guān)的東西，就不能放在子線程中，因為子線程是不能操作UI的，只能進(jìn)行數(shù)據(jù)、系統(tǒng)等其他非UI的操作。
那么什么情況下面我們的子線程才能看做是一個有Looper的線程呢？我們?nèi)绾蔚玫剿麹ooper的句柄呢？
Looper.myLooper();獲得當(dāng)前的Looper
Looper.getMainLooper () 獲得UI線程的Lopper
我們看看Handle的初始化函數(shù)，如果沒有參數(shù)，那么他就默認(rèn)使用的是當(dāng)前的Looper，如果有Looper參數(shù)，就是用對應(yīng)的線程的Looper。
如果一個線程中調(diào)用Looper.prepare()，那么系統(tǒng)就會自動的為該線程建立一個消息隊列，然后調(diào)用 Looper.loop();之后就進(jìn)入了消息循環(huán)，這個之后就可以發(fā)消息、取消息、和處理消息。這個如何發(fā)送消息和如何處理消息可以再其他的線程中通過Handle來做，但前提是我們的Hanle知道這個子線程的Looper，但是你如果不是在子線程運(yùn)行 Looper.myLooper()，一般是得不到子線程的looper的。
public void run() {
? ?? ?? ?? ?synchronized (mLock) {
? ?? ?? ?? ?? ? Looper.prepare();
? ?? ?? ?? ?? ?//do something
? ?? ?? ?? ?}
? ?? ?? ?? ?Looper.loop();
? ?? ???}
所以很多人都是這樣做的：我直接在子線程中新建handle，然后在子線程中發(fā)送消息，這樣的話就失去了我們多線程的意義了。
class myThread extends Thread{
? ?? ?? ?? ? private EHandler mHandler ;
? ?? ?? ?? ? public void run() {
? ?? ?? ?? ?? ???Looper myLooper, mainLooper;
? ?? ?? ?? ?? ???myLooper = Looper.myLooper ();
? ?? ?? ?? ?? ? mainLooper = Looper.getMainLooper ();
? ?? ?? ?? ?? ? String obj;
? ?? ?? ?? ?? ? if (myLooper == null ){
? ?? ?? ?? ?? ?? ?? ?? ? mHandler = new EHandler(mainLooper);
? ?? ?? ?? ?? ?? ?? ?? ? obj = "current thread has no looper!" ;
? ?? ?? ?? ?? ? }
? ?? ?? ?? ?? ? else {
? ?? ?? ?? ?? ?? ?? ?mHandler = new EHandler(myLooper);
? ?? ?? ?? ?? ?? ?? ?obj = "This is from current thread." ;
? ?? ?? ?? ?? ? }
? ?? ?? ?? ?? ? mHandler .removeMessages(0);
? ?? ?? ?? ?? ? Message m = mHandler .obtainMessage(1, 1, 1, obj);
? ?? ?? ?? ?? ? mHandler .sendMessage(m);
? ?? ?? ?? ? }
??}
可以讓其他的線程來控制我們的handle，可以把 private EHandler mHandler ;放在外面，這樣我們的發(fā)消息和處理消息都可以在外面來定義，這樣增加程序代碼的美觀，結(jié)構(gòu)更加清晰。
對如任何的Handle，里面必須要重載一個函數(shù)
public void handleMessage(Message msg)
這個函數(shù)就是我們的消息處理，如何處理，這里完全取決于你，然后通過 obtainMessage和 sendMessage等來生成和發(fā)送消息， removeMessages(0)來清除消息隊列。Google真是太智慧了，這種框架的產(chǎn)生，我們寫代碼更加輕松了。
有的時候，我們的子線程想去改變UI了，這個時候千萬不要再子線程中去修改，獲得UI線程的Looper，然后發(fā)送消息即可。
我們看看Goole Music App的源代碼。
在MediaPlaybackActivity.java中，我們可以看一下再OnCreate中的有這樣的兩句：
? ?? ???mAlbumArtWorker = new Worker("album art worker");
? ?? ???mAlbumArtHandler = new AlbumArtHandler(mAlbumArtWorker.getLooper());
很明顯這兩句，是構(gòu)建了一個子線程。并且這個子線程還是Looper的子線程，這里很牛逼的使用了 mAlbumArtWorker.getLooper()這個函數(shù)，因為我們知道，我們能夠得到子線程的Looper的途徑只有一個：就是在子線程中調(diào)用 Looper.myLooper ()，并且這個函數(shù)還要在我們perpare之后調(diào)用才能得到正確的Looper，但是他這里用了一個這樣的什么東東 getLooper，不知道它是如何實現(xiàn)的？
這里有一個大概的思路，我們在子線程的的prepare之后調(diào)用 myLooper ()這個方法，然后保存在一個成員變量中，這個getLooper就返回這個東西，但是這里會碰到多線程的一個很突出的問題，同步。我們在父線程中調(diào)用 mAlbumArtWorker.getLooper()，但是想要這個返回正確的looper就必須要求我們的子線程運(yùn)行了prepare，但是這個東西實在子線程運(yùn)行的，我們?nèi)绾伪ＷC呢？
我們看Google是如何實現(xiàn)的？
? ?private class Worker implements Runnable {
? ?? ???private final Object mLock = new Object();
? ?? ???private Looper mLooper;
? ?? ???
? ?? ???/**
? ?? ?? ?* Creates a worker thread with the given name. The thread
? ?? ?? ?* then runs a [email=%7B@link]{@link[/email] android.os.Looper}.
? ?? ?? ?* @param name A name for the new thread
? ?? ?? ?*/
? ?? ???Worker(String name) {
? ?? ?? ?? ?Thread t = new Thread(null, this, name);
? ?? ?? ?? ?t.setPriority(Thread.MIN_PRIORITY);
? ?? ?? ?? ?t.start();
? ?? ?? ?? ?synchronized (mLock) {
? ?? ?? ?? ?? ? while (mLooper == null) {
? ?? ?? ?? ?? ?? ???try {
? ?? ?? ?? ?? ?? ?? ?? ?mLock.wait();
? ?? ?? ?? ?? ?? ???} catch (InterruptedException ex) {
? ?? ?? ?? ?? ?? ???}
? ?? ?? ?? ?? ? }
? ?? ?? ?? ?}
? ?? ???}
? ?? ???
? ?? ???public Looper getLooper() {
? ?? ?? ?? ?return mLooper;
? ?? ???}
? ?? ???
? ?? ???public void run() {
? ?? ?? ?? ?synchronized (mLock) {
? ?? ?? ?? ?? ? Looper.prepare();
? ?? ?? ?? ?? ? mLooper = Looper.myLooper();
? ?? ?? ?? ?? ? mLock.notifyAll();
? ?? ?? ?? ?}
? ?? ?? ?? ?Looper.loop();
? ?? ???}
? ?? ???
? ?? ???public void quit() {
? ?? ?? ?? ?mLooper.quit();
? ?? ???}
? ? }
我們知道，一個線程類的構(gòu)造函數(shù)是在主線程中完成的，所以在我們的 Worker的構(gòu)造函數(shù)中我們創(chuàng)佳一個線程，然后讓這個線程運(yùn)行，這一這個線程的創(chuàng)建是指定一個 Runnabl，這里就是我們的Worker本身，在主線程調(diào)用 t.start();，這后，我們子線程已經(jīng)創(chuàng)建，并且開始執(zhí)行work的run方法。然后下面的代碼很藝術(shù)：
synchronized (mLock) {
? ?? ?? ?? ?? ? while (mLooper == null) {
? ?? ?? ?? ?? ?? ???try {
? ?? ?? ?? ?? ?? ?? ?? ?mLock.wait();
? ?? ?? ?? ?? ?? ???} catch (InterruptedException ex) {
? ?? ?? ?? ?? ?? ???}
? ?? ?? ?? ?? ? }
? ?? ?? ?? ?}
我們開始等待我們的子線程給mLooper賦值，如果不賦值我們就繼續(xù)等，然后我們的子線程在運(yùn)行run方法之后，在給 mLooper賦值之后，通知worker夠著函數(shù)中的wait，然后我們的構(gòu)造函數(shù)才能完成，所以我們說：
mAlbumArtWorker = new Worker("album art worker");
這句本身就是阻塞的，它創(chuàng)建了一個子線程，開啟了子線程，并且等待子線程給mLooper賦值，賦值完成之后，這個函數(shù)才返回，這樣才能保證我們的子線程的Looper的獲取絕對是正確的，這個構(gòu)思很有創(chuàng)意。值得借鑒
Android中Handler的使用方法——在子線程中更新界面
本文主要介紹Android的Handler的使用方法。Handler可以發(fā)送Messsage和Runnable對象到與其相關(guān)聯(lián)的線程的消息隊列。每個Handler對象與創(chuàng)建它的線程相關(guān)聯(lián)，并且每個Handler對象只能與一個線程相關(guān)聯(lián)。
1.??? Handler一般有兩種用途：1）執(zhí)行計劃任務(wù)，你可以再預(yù)定的實現(xiàn)執(zhí)行某些任務(wù)，可以模擬定時器。2）線程間通信。在Android的應(yīng)用啟動時，會創(chuàng)建一個主線程，主線程會創(chuàng)建一個消息隊列來處理各種消息。當(dāng)你創(chuàng)建子線程時，你可以再你的子線程中拿到父線程中創(chuàng)建的Handler對象，就可以通過該對象向父線程的消息隊列發(fā)送消息了。由于Android要求在UI線程中更新界面，因此，可以通過該方法在其它線程中更新界面。
◆ 通過Runnable在子線程中更新界面的例子
1.○ 在onCreate中創(chuàng)建Handler?
public class HandlerTestApp extends Activity {?
??????? Handler mHandler;?
??????? TextView mText;?
??????? /** Called when the activity is first created. */?
?????? @Override?
?????? public void onCreate(Bundle savedInstanceState) {?
?????????? super.onCreate(savedInstanceState);?
?????????? setContentView(R.layout.main);?
?????????? mHandler = new Handler();//創(chuàng)建Handler?
?????????? mText = (TextView) findViewById(R.id.text0);//一個TextView?
?????? }?
???? ○ 構(gòu)建Runnable對象，在runnable中更新界面，此處，我們修改了TextView的文字.此處需要說明的是，Runnable對象可以再主線程中創(chuàng)建，也可以再子線程中創(chuàng)建。我們此處是在子線程中創(chuàng)建的。?
???? Runnable mRunnable0 = new Runnable()?
??? {?
??????????????? @Override?
??????????????? public void run() {?
??????????????????????? mText.setText("This is Update from ohter thread, Mouse DOWN");
??????????????? }?
??? };?
???? ○ 創(chuàng)建子線程，在線程的run函數(shù)中，我們向主線程的消息隊列發(fā)送了一個runnable來更新界面。
??? private void updateUIByRunnable(){?
????????? new Thread()??
???????? {??
?????????????? //Message msg = mHandler.obtainMessage();??
????????????? public void run()??
???????????? {?
?????????????????? //mText.setText("This is Update from ohter thread, Mouse DOWN");//這句將拋出異常
???????????????????mHandler.post(mRunnable0);??
???????????? }??
???????? }.start();
???? }
◆ 用Message在子線程中來更新界面
1.??? 用Message更新界面與Runnable更新界面類似，只是需要修改幾個地方。
??? ○ 實現(xiàn)自己的Handler，對消息進(jìn)行處理
??? private class?MyHandler?extends Handler
??? {?
??????? @Override?
??????? public void handleMessage(Message msg) {?
??????????? super.handleMessage(msg);?
??????????? switch(msg.what)?
??????????? {?
??????????? case?UPDATE://在收到消息時，對界面進(jìn)行更新?
??????????????? mText.setText("This update by message");?
??????????????? break;?
??????????? }?
??????? }?
??? }
??? ○ 在新的線程中發(fā)送消息?????
??? private void updateByMessage()?
??? {?
??????? //匿名對象?
???????? new Thread()?
???????? {?
??????????????? public void run()?
??????????????? {?
??????????????????? //mText.setText("This is Update from ohter thread, Mouse DOWN");
??????????????????? //UPDATE是一個自己定義的整數(shù)，代表了消息ID?
??????????????????? Message msg = mHandler.obtainMessage(UPDATE);
????????????????????mHandler.sendMessage(msg);
??????????????? }?
???????? }.start();?
??? }
?
---------------------------------------------------------------------------------------------華麗的分割線----------------------------------------------------------------------------------------------
?
?
android的消息處理有三個核心類：Looper,Handler和Message。其實還有一個Message Queue（消息隊列），但是MQ被封裝到Looper里面了，我們不會直接與MQ打交道，因此我沒將其作為核心類。下面一一介紹：
線程的魔法師 Looper
Looper的字面意思是“循環(huán)者”，它被設(shè)計用來使一個普通線程變成Looper線程。所謂Looper線程就是循環(huán)工作的線程。在程序開發(fā)中（尤其是GUI開發(fā)中），我們經(jīng)常會需要一個線程不斷循環(huán)，一旦有新任務(wù)則執(zhí)行，執(zhí)行完繼續(xù)等待下一個任務(wù)，這就是Looper線程。使用Looper類創(chuàng)建Looper線程很簡單：
[java]?view plaincopyprint?通過上面兩行核心代碼，你的線程就升級為Looper線程了！！！是不是很神奇？讓我們放慢鏡頭，看看這兩行代碼各自做了什么。
1)Looper.prepare()
通過上圖可以看到，現(xiàn)在你的線程中有一個Looper對象，它的內(nèi)部維護(hù)了一個消息隊列MQ。注意，一個Thread只能有一個Looper對象，為什么呢？咱們來看源碼。
[java]?view plaincopyprint?通過源碼，prepare()背后的工作方式一目了然，其核心就是將looper對象定義為ThreadLocal。如果你還不清楚什么是ThreadLocal，請參考《理解ThreadLocal》。
2）Looper.loop()
調(diào)用loop方法后，Looper線程就開始真正工作了，它不斷從自己的MQ中取出隊頭的消息(也叫任務(wù))執(zhí)行。其源碼分析如下：
[java]?view plaincopyprint?除了prepare()和loop()方法，Looper類還提供了一些有用的方法，比如
Looper.myLooper()得到當(dāng)前線程looper對象：
[java]?view plaincopyprint?getThread()得到looper對象所屬線程：
[java]?view plaincopyprint?quit()方法結(jié)束looper循環(huán)：
[java]?view plaincopyprint?到此為止，你應(yīng)該對Looper有了基本的了解，總結(jié)幾點：
1.每個線程有且最多只能有一個Looper對象，它是一個ThreadLocal
2.Looper內(nèi)部有一個消息隊列，loop()方法調(diào)用后線程開始不斷從隊列中取出消息執(zhí)行
3.Looper使一個線程變成Looper線程。
那么，我們?nèi)绾瓮鵐Q上添加消息呢？下面有請Handler！（掌聲~~~）
異步處理大師 Handler
什么是handler？handler扮演了往MQ上添加消息和處理消息的角色（只處理由自己發(fā)出的消息），即通知MQ它要執(zhí)行一個任務(wù)(sendMessage)，并在loop到自己的時候執(zhí)行該任務(wù)(handleMessage)，整個過程是異步的。handler創(chuàng)建時會關(guān)聯(lián)一個looper，默認(rèn)的構(gòu)造方法將關(guān)聯(lián)當(dāng)前線程的looper，不過這也是可以set的。默認(rèn)的構(gòu)造方法：
[java]?view plaincopyprint?下面我們就可以為之前的LooperThread類加入Handler：
[java]?view plaincopyprint?加入handler后的效果如下圖：
可以看到，一個線程可以有多個Handler，但是只能有一個Looper！
Handler發(fā)送消息
有了handler之后，我們就可以使用?post(Runnable),postAtTime(Runnable, long),postDelayed(Runnable, long),sendEmptyMessage(int),sendMessage(Message),sendMessageAtTime(Message, long)和sendMessageDelayed(Message, long)這些方法向MQ上發(fā)送消息了。光看這些API你可能會覺得handler能發(fā)兩種消息，一種是Runnable對象，一種是message對象，這是直觀的理解，但其實post發(fā)出的Runnable對象最后都被封裝成message對象了，見源碼：
[java]?view plaincopyprint?其他方法就不羅列了，總之通過handler發(fā)出的message有如下特點：
1.message.target為該handler對象，這確保了looper執(zhí)行到該message時能找到處理它的handler，即loop()方法中的關(guān)鍵代碼
msg.target.dispatchMessage(msg);2.post發(fā)出的message，其callback為Runnable對象
Handler處理消息
說完了消息的發(fā)送，再來看下handler如何處理消息。消息的處理是通過核心方法dispatchMessage(Message?msg)與鉤子方法handleMessage(Message?msg)完成的，見源碼
[java]?view plaincopyprint?可以看到，除了handleMessage(Message?msg)和Runnable對象的run方法由開發(fā)者實現(xiàn)外（實現(xiàn)具體邏輯），handler的內(nèi)部工作機(jī)制對開發(fā)者是透明的。這正是handler API設(shè)計的精妙之處！
Handler的用處
我在小標(biāo)題中將handler描述為“異步處理大師”，這歸功于Handler擁有下面兩個重要的特點：
1.handler可以在任意線程發(fā)送消息，這些消息會被添加到關(guān)聯(lián)的MQ上。
??????????????
2.handler是在它關(guān)聯(lián)的looper線程中處理消息的。
這就解決了android最經(jīng)典的不能在其他非主線程中更新UI的問題。android的主線程也是一個looper線程(looper在android中運(yùn)用很廣)，我們在其中創(chuàng)建的handler默認(rèn)將關(guān)聯(lián)主線程MQ。因此，利用handler的一個solution就是在activity中創(chuàng)建handler并將其引用傳遞給worker thread，worker thread執(zhí)行完任務(wù)后使用handler發(fā)送消息通知activity更新UI。(過程如圖)
當(dāng)然，handler能做的遠(yuǎn)遠(yuǎn)不僅如此，由于它能post Runnable對象，它還能與Looper配合實現(xiàn)經(jīng)典的Pipeline Thread(流水線線程)模式。請參考此文《Android Guts: Intro to Loopers and Handlers》
封裝任務(wù) Message
在整個消息處理機(jī)制中，message又叫task，封裝了任務(wù)攜帶的信息和處理該任務(wù)的handler。message的用法比較簡單，這里不做總結(jié)了。但是有這么幾點需要注意（待補(bǔ)充）：
1.盡管Message有public的默認(rèn)構(gòu)造方法，但是你應(yīng)該通過Message.obtain()來從消息池中獲得空消息對象，以節(jié)省資源。
2.如果你的message只需要攜帶簡單的int信息，請優(yōu)先使用Message.arg1和Message.arg2來傳遞信息，這比用Bundle更省內(nèi)存
3.擅用message.what來標(biāo)識信息，以便用不同方式處理message。
?
?
---------------------------------------------------------------------------------------------華麗的分割線----------------------------------------------------------------------------------------------
?
??????? 我們知道，Android應(yīng)用程序是通過消息來驅(qū)動的，即在應(yīng)用程序的主線程（UI線程）中有一個消息循環(huán)，負(fù)責(zé)處理消息隊列中的消息。我們也知道，Android應(yīng)用程序是支持多線程的，即可以創(chuàng)建子線程來執(zhí)行一些計算型的任務(wù)，那么，這些子線程能不能像應(yīng)用程序的主線程一樣具有消息循環(huán)呢？這些子線程又能不能往應(yīng)用程序的主線程中發(fā)送消息呢？本文將分析Android應(yīng)用程序線程消息處理模型，為讀者解答這兩個問題
?? ? ? ?在開發(fā)Android應(yīng)用程序中，有時候我們需要在應(yīng)用程序中創(chuàng)建一些常駐的子線程來不定期地執(zhí)行一些不需要與應(yīng)用程序界面交互的計算型的任務(wù)。如果這些子線程具有消息循環(huán)，那么它們就能夠常駐在應(yīng)用程序中不定期的執(zhí)行一些計算型任務(wù)了：當(dāng)我們需要用這些子線程來執(zhí)行任務(wù)時，就往這個子線程的消息隊列中發(fā)送一個消息，然后就可以在子線程的消息循環(huán)中執(zhí)行我們的計算型任務(wù)了。我們在前面一篇文章Android系統(tǒng)默認(rèn)Home應(yīng)用程序（Launcher）的啟動過程源代碼分析中，介紹Launcher的啟動過程時，在Step 15（LauncherModel.startLoader）中，Launcher就是通過往一個子線程的消息隊列中發(fā)送一個消息（sWorker.post(mLoaderTask)），然后子線程就會在它的消息循環(huán)中處理這個消息的時候執(zhí)行從PackageManagerService中獲取系統(tǒng)中已安裝應(yīng)用程序的信息列表的任務(wù)，即調(diào)用Step 16中的LoaderTask.run函數(shù)。
?? ? ? ?在開發(fā)Android應(yīng)用程序中，有時候我們又需要在應(yīng)用程序中創(chuàng)建一些子線程來執(zhí)行一些需要與應(yīng)用程序界面進(jìn)交互的計算型任務(wù)。典型的應(yīng)用場景是當(dāng)我們要從網(wǎng)上下載文件時，為了不使主線程被阻塞，我們通常創(chuàng)建一個子線程來負(fù)責(zé)下載任務(wù)，同時，在下載的過程，將下載進(jìn)度以百分比的形式在應(yīng)用程序的界面上顯示出來，這樣就既不會阻塞主線程的運(yùn)行，又能獲得良好的用戶體驗。但是，我們知道，Android應(yīng)用程序的子線程是不可以操作主線程的UI的，那么，這個負(fù)責(zé)下載任務(wù)的子線程應(yīng)該如何在應(yīng)用程序界面上顯示下載的進(jìn)度呢？如果我們能夠在子線程中往主線程的消息隊列中發(fā)送消息，那么問題就迎刃而解了，因為發(fā)往主線程消息隊列的消息最終是由主線程來處理的，在處理這個消息的時候，我們就可以在應(yīng)用程序界面上顯示下載進(jìn)度了。
?? ? ? ?上面提到的這兩種情況，Android系統(tǒng)都為我們提供了完善的解決方案，前者可以通過使用HandlerThread類來實現(xiàn)，而后者可以使用AsyncTask類來實現(xiàn)，本文就詳細(xì)這兩個類是如何實現(xiàn)的。不過，為了更好地理解HandlerThread類和AsyncTask類的實現(xiàn)，我們先來看看應(yīng)用程序的主線程的消息循環(huán)模型是如何實現(xiàn)的。
?? ? ? ?1. 應(yīng)用程序主線程消息循環(huán)模型
?? ? ? ?在前面一篇文章Android應(yīng)用程序進(jìn)程啟動過程的源代碼分析一文中，我們已經(jīng)分析應(yīng)用程序進(jìn)程（主線程）的啟動過程了，這里主要是針對它的消息循環(huán)模型作一個總結(jié)。當(dāng)運(yùn)行在Android應(yīng)用程序框架層中的ActivityManagerService決定要為當(dāng)前啟動的應(yīng)用程序創(chuàng)建一個主線程的時候，它會在ActivityManagerService中的startProcessLocked成員函數(shù)調(diào)用Process類的靜態(tài)成員函數(shù)start為當(dāng)前應(yīng)用程序創(chuàng)建一個主線程：
view plain?? ? ? ?這里我們主要關(guān)注Process.start函數(shù)的第一個參數(shù)“android.app.ActivityThread”，它表示要在當(dāng)前新建的線程中加載android.app.ActivityThread類，并且調(diào)用這個類的靜態(tài)成員函數(shù)main作為應(yīng)用程序的入口點。ActivityThread類定義在frameworks/base/core/java/android/app/ActivityThread.java文件中：
view plain?? ? ? ?在這個main函數(shù)里面，除了創(chuàng)建一個ActivityThread實例外，就是在進(jìn)行消息循環(huán)了。
?? ? ? ?在進(jìn)行消息循環(huán)之前，首先會通過Looper類的靜態(tài)成員函數(shù)prepareMainLooper為當(dāng)前線程準(zhǔn)備一個消息循環(huán)對象。Looper類定義在frameworks/base/core/java/android/os/Looper.java文件中：
view plain?? ? ? ?Looper類的靜態(tài)成員函數(shù)prepareMainLooper是專門應(yīng)用程序的主線程調(diào)用的，應(yīng)用程序的其它子線程都不應(yīng)該調(diào)用這個函數(shù)來在本線程中創(chuàng)建消息循環(huán)對象，而應(yīng)該調(diào)用prepare函數(shù)來在本線程中創(chuàng)建消息循環(huán)對象，下一節(jié)我們介紹一個線程類HandlerThread 時將會看到。
?? ? ? ?為什么要為應(yīng)用程序的主線程專門準(zhǔn)備一個創(chuàng)建消息循環(huán)對象的函數(shù)呢？這是為了讓其它地方能夠方便地通過Looper類的getMainLooper函數(shù)來獲得應(yīng)用程序主線程中的消息循環(huán)對象。獲得應(yīng)用程序主線程中的消息循環(huán)對象又有什么用呢？一般就是為了能夠向應(yīng)用程序主線程發(fā)送消息了。
?? ? ? ?在prepareMainLooper函數(shù)中，首先會調(diào)用prepare函數(shù)在本線程中創(chuàng)建一個消息循環(huán)對象，然后將這個消息循環(huán)對象放在線程局部變量sThreadLocal中：
view plain?? ? ? ?接著再將這個消息循環(huán)對象通過調(diào)用setMainLooper函數(shù)來保存在Looper類的靜態(tài)成員變量mMainLooper中：
view plain?? ? ? 這樣，其它地方才可以調(diào)用getMainLooper函數(shù)來獲得應(yīng)用程序主線程中的消息循環(huán)對象。
?? ? ? 消息循環(huán)對象創(chuàng)建好之后，回到ActivityThread類的main函數(shù)中，接下來，就是要進(jìn)入消息循環(huán)了：
view plain?? ? ? ?Looper類具體是如何通過loop函數(shù)進(jìn)入消息循環(huán)以及處理消息隊列中的消息，可以參考前面一篇文章Android應(yīng)用程序消息處理機(jī)制（Looper、Handler）分析，這里就不再分析了，我們只要知道ActivityThread類中的main函數(shù)執(zhí)行了這一步之后，就為應(yīng)用程序的主線程準(zhǔn)備好消息循環(huán)就可以了。
?? ? ? ?2. 應(yīng)用程序子線程消息循環(huán)模型
?? ? ? ?在Java框架中，如果我們想在當(dāng)前應(yīng)用程序中創(chuàng)建一個子線程，一般就是通過自己實現(xiàn)一個類，這個類繼承于Thread類，然后重載Thread類的run函數(shù)，把我們想要在這個子線程執(zhí)行的任務(wù)都放在這個run函數(shù)里面實現(xiàn)。最后實例這個自定義的類，并且調(diào)用它的start函數(shù)，這樣一個子線程就創(chuàng)建好了，并且會調(diào)用這個自定義類的run函數(shù)。但是當(dāng)這個run函數(shù)執(zhí)行完成后，子線程也就結(jié)束了，它沒有消息循環(huán)的概念。
?? ? ? ?前面說過，有時候我們需要在應(yīng)用程序中創(chuàng)建一些常駐的子線程來不定期地執(zhí)行一些計算型任務(wù)，這時候就可以考慮使用Android系統(tǒng)提供的HandlerThread類了，它具有創(chuàng)建具有消息循環(huán)功能的子線程的作用。
?? ? ? ?HandlerThread類實現(xiàn)在frameworks/base/core/java/android/os/HandlerThread.java文件中，這里我們通過使用情景來有重點的分析它的實現(xiàn)。
?? ? ? ?在前面一篇文章Android系統(tǒng)默認(rèn)Home應(yīng)用程序（Launcher）的啟動過程源代碼分析中，我們分析了Launcher的啟動過程，其中在Step 15（LauncherModel.startLoader）和Step 16（LoaderTask.run）中，Launcher會通過創(chuàng)建一個HandlerThread類來實現(xiàn)在一個子線程加載系統(tǒng)中已經(jīng)安裝的應(yīng)用程序的任務(wù)：
view plain?? ? ? ?在這個LauncherModel類中，首先創(chuàng)建了一個HandlerThread對象：
view plain?? ? ? ?接著調(diào)用它的start成員函數(shù)來啟動一個子線程：
view plain?? ? ? ?接著還通過這個HandlerThread對象的getLooper函數(shù)來獲得這個子線程中的消息循環(huán)對象，并且使用這個消息循環(huán)創(chuàng)建對象來創(chuàng)建一個Handler：
view plain?? ? ? ?有了這個Handler對象sWorker之后，我們就可以往這個子線程中發(fā)送消息，然后在處理這個消息的時候執(zhí)行加載系統(tǒng)中已經(jīng)安裝的應(yīng)用程序的任務(wù)了，在startLoader函數(shù)中：
view plain?? ? ? ?這里的mLoaderTask是一個LoaderTask對象，它實現(xiàn)了Runnable接口，因此，可以把這個LoaderTask對象作為參數(shù)傳給sWorker.post函數(shù)。在sWorker.post函數(shù)里面，會把這個LoaderTask對象封裝成一個消息，并且放入這個子線程的消息隊列中去。當(dāng)這個子線程的消息循環(huán)處理這個消息的時候，就會調(diào)用這個LoaderTask對象的run函數(shù)，因此，我們就可以在LoaderTask對象的run函數(shù)中通過調(diào)用loadAndBindAllApps來執(zhí)行加載系統(tǒng)中已經(jīng)安裝的應(yīng)用程序的任務(wù)了。
?? ? ? ?了解了HanderThread類的使用方法之后，我們就可以重點地來分析它的實現(xiàn)了：
view plain?? ? ? ?首先我們看到的是，Handler類繼承了Thread類，因此，通過它可以在應(yīng)用程序中創(chuàng)建一個子線程，其次我們看到在它的run函數(shù)中，會進(jìn)入一個消息循環(huán)中，因此，這個子線程可以常駐在應(yīng)用程序中，直到它接收收到一個退出消息為止。
?? ? ? ?在run函數(shù)中，首先是調(diào)用Looper類的靜態(tài)成員函數(shù)prepare來準(zhǔn)備一個消息循環(huán)對象：
view plain?? ? ? ?然后通過Looper類的myLooper成員函數(shù)將這個子線程中的消息循環(huán)對象保存在HandlerThread類中的成員變量mLooper中：
view plain?? ? ? ?這樣，其它地方就可以方便地通過它的getLooper函數(shù)來獲得這個消息循環(huán)對象了，有了這個消息循環(huán)對象后，就可以往這個子線程的消息隊列中發(fā)送消息，通知這個子線程執(zhí)行特定的任務(wù)了。
?? ? ? ?最在這個run函數(shù)通過Looper類的loop函數(shù)進(jìn)入消息循環(huán)中：
view plain?? ? ? ?這樣，一個具有消息循環(huán)的應(yīng)用程序子線程就準(zhǔn)備就緒了。
?? ? ? ?HandlerThread類的實現(xiàn)雖然非常簡單，當(dāng)然這得益于Java提供的Thread類和Android自己本身提供的Looper類，但是它的想法卻非常周到，為應(yīng)用程序開發(fā)人員提供了很大的方便。
?? ? ? ?3. 需要與UI交互的應(yīng)用程序子線程消息模型
?? ? ? ?前面說過，我們開發(fā)應(yīng)用程序的時候，經(jīng)常中需要創(chuàng)建一個子線程來在后臺執(zhí)行一個特定的計算任務(wù)，而在這個任務(wù)計算的過程中，需要不斷地將計算進(jìn)度或者計算結(jié)果展現(xiàn)在應(yīng)用程序的界面中。典型的例子是從網(wǎng)上下載文件，為了不阻塞應(yīng)用程序的主線程，我們開辟一個子線程來執(zhí)行下載任務(wù)，子線程在下載的同時不斷地將下載進(jìn)度在應(yīng)用程序界面上顯示出來，這樣做出來程序就非常友好。由于子線程不能直接操作應(yīng)用程序的UI，因此，這時候，我們就可以通過往應(yīng)用程序的主線程中發(fā)送消息來通知應(yīng)用程序主線程更新界面上的下載進(jìn)度。因為類似的這種情景在實際開發(fā)中經(jīng)常碰到，Android系統(tǒng)為開發(fā)人員提供了一個異步任務(wù)類（AsyncTask）來實現(xiàn)上面所說的功能，即它會在一個子線程中執(zhí)行計算任務(wù)，同時通過主線程的消息循環(huán)來獲得更新應(yīng)用程序界面的機(jī)會。
?? ? ? ?為了更好地分析AsyncTask的實現(xiàn)，我們先舉一個例子來說明它的用法。在前面一篇文章Android系統(tǒng)中的廣播（Broadcast）機(jī)制簡要介紹和學(xué)習(xí)計劃中，我們開發(fā)了一個應(yīng)用程序Broadcast，其中使用了AsyncTask來在一個線程在后臺在執(zhí)行計數(shù)任務(wù)，計數(shù)過程通過廣播（Broadcast）來將中間結(jié)果在應(yīng)用程序界面上顯示出來。在這個例子中，使用廣播來在應(yīng)用程序主線程和子線程中傳遞數(shù)據(jù)不是最優(yōu)的方法，當(dāng)時只是為了分析Android系統(tǒng)的廣播機(jī)制而有意為之的。在本節(jié)內(nèi)容中，我們稍微這個例子作一個簡單的修改，就可以通過消息的方式來將計數(shù)過程的中間結(jié)果在應(yīng)用程序界面上顯示出來。
?? ? ? ?為了區(qū)別Android系統(tǒng)中的廣播（Broadcast）機(jī)制簡要介紹和學(xué)習(xí)計劃一文中使用的應(yīng)用程序Broadcast，我們將本節(jié)中使用的應(yīng)用程序命名為Counter。首先在Android源代碼工程中創(chuàng)建一個Android應(yīng)用程序工程，名字就為Counter，放在packages/experimental目錄下。關(guān)于如何獲得Android源代碼工程，請參考在Ubuntu上下載、編譯和安裝Android最新源代碼一文；關(guān)于如何在Android源代碼工程中創(chuàng)建應(yīng)用程序工程，請參考在Ubuntu上為Android系統(tǒng)內(nèi)置Java應(yīng)用程序測試Application Frameworks層的硬件服務(wù)一文。這個應(yīng)用程序工程定義了一個名為shy.luo.counter的package，這個例子的源代碼主要就是實現(xiàn)在這個目錄下的Counter.java文件中：
view plain?? ? ? ?這個計數(shù)器程序很簡單，它在界面上有兩個按鈕Start和Stop。點擊Start按鈕時，便會創(chuàng)建一個CounterTask實例task，然后調(diào)用它的execute函數(shù)就可以在應(yīng)用程序中啟動一個子線程，并且通過調(diào)用這個CounterTask類的doInBackground函數(shù)來執(zhí)行計數(shù)任務(wù)。在計數(shù)的過程中，會通過調(diào)用publishProgress函數(shù)來將中間結(jié)果傳遞到onProgressUpdate函數(shù)中去，在onProgressUpdate函數(shù)中，就可以把中間結(jié)果顯示在應(yīng)用程序界面了。點擊Stop按鈕時，便會通過設(shè)置變量stop為true，這樣，CounterTask類的doInBackground函數(shù)便會退出循環(huán)，然后將結(jié)果返回到onPostExecute函數(shù)中去，在onPostExecute函數(shù)，會把最終計數(shù)結(jié)果顯示在用程序界面中。
?? ? ? 在這個例子中，我們需要注意的是：
?? ? ? A. CounterTask類繼承于AsyncTask類，因此它也是一個異步任務(wù)類；
?? ? ? B.?CounterTask類的doInBackground函數(shù)是在后臺的子線程中運(yùn)行的，這時候它不可以操作應(yīng)用程序的界面；
?? ? ? C.?CounterTask類的onProgressUpdate和onPostExecute兩個函數(shù)是應(yīng)用程序的主線程中執(zhí)行，它們可以操作應(yīng)用程序的界面。
?? ? ? 關(guān)于C這一點的實現(xiàn)原理，我們在后面會分析到，這里我們先完整地介紹這個例子，以便讀者可以參考做一下實驗。
?? ? ? 接下來我們再看看應(yīng)用程序的配置文件AndroidManifest.xml：
view plain?? ? ? 這個配置文件很簡單，我們就不介紹了。
?? ? ??再來看應(yīng)用程序的界面文件，它定義在res/layout/main.xml文件中：
view plain?? ? ? 這個界面配置文件也很簡單，等一下我們在模擬器把這個應(yīng)用程序啟動起來后，就可以看到它的截圖了。
?? ? ??應(yīng)用程序用到的字符串資源文件位于res/values/strings.xml文件中：
view plain?? ? ? 最后，我們還要在工程目錄下放置一個編譯腳本文件Android.mk：
view plain?? ? ??接下來就要編譯了。有關(guān)如何單獨編譯Android源代碼工程的模塊，以及如何打包system.img，請參考如何單獨編譯Android源代碼中的模塊一文。
?? ? ? 執(zhí)行以下命令進(jìn)行編譯和打包：
?? ? ??這樣，打包好的Android系統(tǒng)鏡像文件system.img就包含我們前面創(chuàng)建的Counter應(yīng)用程序了。
?? ? ? 再接下來，就是運(yùn)行模擬器來運(yùn)行我們的例子了。關(guān)于如何在Android源代碼工程中運(yùn)行模擬器，請參考在Ubuntu上下載、編譯和安裝Android最新源代碼一文。
?? ? ? 執(zhí)行以下命令啟動模擬器：
?? ? ? 最后我們就可以在Launcher中找到Counter應(yīng)用程序圖標(biāo)，把它啟動起來，點擊Start按鈕，就會看到應(yīng)用程序界面上的計數(shù)器跑起來了：
?? ? ? ?這樣，使用AsyncTask的例子就介紹完了，下面，我們就要根據(jù)上面對AsyncTask的使用情況來重點分析它的實現(xiàn)了。
?? ? ? ?AsyncTask類定義在frameworks/base/core/java/android/os/AsyncTask.java文件中：
view plain?? ? ? ?從AsyncTask的實現(xiàn)可以看出，當(dāng)我們第一次創(chuàng)建一個AsyncTask對象時，首先會執(zhí)行下面靜態(tài)初始化代碼創(chuàng)建一個線程池sExecutor：
view plain?? ? ? ?這里的ThreadPoolExecutor是Java提供的多線程機(jī)制之一，這里用的構(gòu)造函數(shù)原型為：
view plain?? ? ? ?各個參數(shù)的意義如下：
?? ? ? ?corePoolSize -- 線程池的核心線程數(shù)量
?? ? ? ?maximumPoolSize -- 線程池的最大線程數(shù)量
?? ? ? ?keepAliveTime -- 若線程池的線程數(shù)數(shù)量大于核心線程數(shù)量，那么空閑時間超過keepAliveTime的線程將被回收
?? ? ? ?unit -- 參數(shù)keepAliveTime使用的時間單位
?? ? ? ?workerQueue -- 工作任務(wù)隊列
?? ? ? ?threadFactory -- 用來創(chuàng)建線程池中的線程
?? ? ? ?簡單來說，ThreadPoolExecutor的運(yùn)行機(jī)制是這樣的：每一個工作任務(wù)用一個Runnable對象來表示，當(dāng)我們要把一個工作任務(wù)交給這個線程池來執(zhí)行的時候，就通過調(diào)用ThreadPoolExecutor的execute函數(shù)來把這個工作任務(wù)加入到線程池中去。此時，如果線程池中的線程數(shù)量小于corePoolSize，那么就會調(diào)用threadFactory接口來創(chuàng)建一個新的線程并且加入到線程池中去，再執(zhí)行這個工作任務(wù)；如果線程池中的線程數(shù)量等于corePoolSize，但是工作任務(wù)隊列workerQueue未滿，則把這個工作任務(wù)加入到工作任務(wù)隊列中去等待執(zhí)行；如果線程池中的線程數(shù)量大于corePoolSize，但是小于maximumPoolSize，并且工作任務(wù)隊列workerQueue已經(jīng)滿了，那么就會調(diào)用threadFactory接口來創(chuàng)建一個新的線程并且加入到線程池中去，再執(zhí)行這個工作任務(wù)；如果線程池中的線程量已經(jīng)等于maximumPoolSize了，并且工作任務(wù)隊列workerQueue也已經(jīng)滿了，這個工作任務(wù)就被拒絕執(zhí)行了。
?? ? ? ?創(chuàng)建好了線程池后，再創(chuàng)建一個消息處理器：
view plain?? ? ? ?注意，這行代碼是在應(yīng)用程序的主線程中執(zhí)行的，因此，這個消息處理器sHandler內(nèi)部引用的消息循環(huán)對象looper是應(yīng)用程序主線程的消息循環(huán)對象，消息處理器的實現(xiàn)機(jī)制具體可以參考前面一篇文章Android應(yīng)用程序消息處理機(jī)制（Looper、Handler）分析。
?? ? ? ?AsyncTask類的靜態(tài)初始化代碼執(zhí)行完成之后，才開始創(chuàng)建AsyncTask對象，即執(zhí)行AsyncTask類的構(gòu)造函數(shù)：
view plain?? ? ? ?在AsyncTask類的構(gòu)造函數(shù)里面，主要是創(chuàng)建了兩個對象，分別是一個WorkerRunnable對象mWorker和一個FutureTask對象mFuture。
?? ? ? ?WorkerRunnable類實現(xiàn)了Runnable接口，此外，它的內(nèi)部成員變量mParams用于保存從AsyncTask對象的execute函數(shù)傳進(jìn)來的參數(shù)列表：
view plain?? ? ? ?FutureTask類也實現(xiàn)了Runnable接口，所以它可以作為一個工作任務(wù)通過調(diào)用AsyncTask類的execute函數(shù)添加到sExecuto線程池中去：
view plain?? ? ? 這里的FutureTask對象mFuture是用來封裝前面的WorkerRunnable對象mWorker。當(dāng)mFuture加入到線程池中執(zhí)行時，它調(diào)用的是mWorker對象的call函數(shù)：
view plain?? ? ? ?在call函數(shù)里面，會調(diào)用AsyncTask類的doInBackground函數(shù)來執(zhí)行真正的任務(wù)，這個函數(shù)是要由AsyncTask的子類來實現(xiàn)的，注意，這個函數(shù)是在應(yīng)用程序的子線程中執(zhí)行的，它不可以操作應(yīng)用程序的界面。
?? ? ? ?我們可以通過mFuture對象來操作當(dāng)前執(zhí)行的任務(wù)，例如查詢當(dāng)前任務(wù)的狀態(tài)，它是正在執(zhí)行中，還是完成了，還是被取消了，如果是完成了，還可以通過它獲得任務(wù)的執(zhí)行結(jié)果，如果還沒有完成，可以取消任務(wù)的執(zhí)行。
?? ? ? ?當(dāng)工作任務(wù)mWorker執(zhí)行完成的時候，mFuture對象中的done函數(shù)就會被被調(diào)用，根據(jù)任務(wù)的完成狀況，執(zhí)行相應(yīng)的操作，例如，如果是因為異常而完成時，就會拋異常，如果是正常完成，就會把任務(wù)執(zhí)行結(jié)果封裝成一個AsyncTaskResult對象：
view plain?? ? ? ?其中，成員變量mData保存的是任務(wù)執(zhí)行結(jié)果，而成員變量mTask指向前面我們創(chuàng)建的AsyncTask對象。
?? ? ? ?最后把這個AsyncTaskResult對象封裝成一個消息，并且通過消息處理器sHandler加入到應(yīng)用程序主線程的消息隊列中：
?? ? ? ?這個消息最終就會在InternalHandler類的handleMessage函數(shù)中處理了：
view plain?? ? ? ?在這個函數(shù)里面，最終會調(diào)用前面創(chuàng)建的這個AsyncTask對象的finish函數(shù)來進(jìn)一步處理：
view plain?? ? ? ?這個函數(shù)調(diào)用AsyncTask類的onPostExecute函數(shù)來進(jìn)一步處理，AsyncTask類的onPostExecute函數(shù)一般是要由其子類來重載的，注意，這個函數(shù)是在應(yīng)用程序的主線程中執(zhí)行的，因此，它可以操作應(yīng)用程序的界面。
?? ? ? ?在任務(wù)執(zhí)行的過程當(dāng)中，即執(zhí)行doInBackground函數(shù)時候，可能通過調(diào)用publishProgress函數(shù)來將中間結(jié)果封裝成一個消息發(fā)送到應(yīng)用程序主線程中的消息隊列中去：
?? ? ? ?這個消息最終也是由InternalHandler類的handleMessage函數(shù)來處理的：
view plain?? ? ? ?這里它調(diào)用前面創(chuàng)建的AsyncTask對象的onPorgressUpdate函數(shù)來進(jìn)一步處理，這個函數(shù)一般是由AsyncTask的子類來實現(xiàn)的，注意，這個函數(shù)是在應(yīng)用程序的主線程中執(zhí)行的，因此，它和前面的onPostExecute函數(shù)一樣，可以操作應(yīng)用程序的界面。
?? ? ? 這樣，AsyncTask類的主要實現(xiàn)就介紹完了，結(jié)合前面開發(fā)的應(yīng)用程序Counter來分析，會更好地理解它的實現(xiàn)原理。
?? ? ? 至此，Android應(yīng)用程序線程消息循環(huán)模型就分析完成了，理解它有利于我們在開發(fā)Android應(yīng)用程序時，能夠充分利用多線程的并發(fā)性來提高應(yīng)用程序的性能以及獲得良好的用戶體驗。
?
轉(zhuǎn)自：http://www.cnblogs.com/qingblog/archive/2012/06/27/2566021.html
總結(jié)
以上是生活随笔為你收集整理的Android消息处理机制的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： VM保护技术
- 下一篇： Android系统分区理解及分区目录细解