Handler消息（Message）传递机制详解
我们创建的Service、Activity以及Broadcast均是一个主线程处理，这里我们可以理解为UI线程。google为了保障用户体验，规定主线程（UI界面）5s没响应就报错—ANR异常（Applicationnot Responding），所以较为耗时的操作一般需要开启子线程完成，即Thread。
对于从事过J2ME开发的程序员来说Thread比较简单，直接匿名创建重写run方法，调用start方法执行即可，或者从Runnable接口继承，但对于Android平台来说UI控件都没有设计成为线程安全类型，所以需要引入一些同步的机制来使其刷新，因为Google做了限定，只有主线程才可以与UI界面进行交互只有主（进度条除外），即刷新UI元素，所以仅仅使用Thread无法将运行结果刷新到UI界面，所以android搞了一个消息机制Handler，利用Handler建立子线程与主线程UI之间的交互联系。
Handler工作模式大致是：
子线程：在一个线程的run方法中，将运行结果存放到Message，然后调用handler对象的 postMessage或sendMessage方法来实现将Message发送到主线程即UI线程，每一个消息都有一个标示Message.what以方便辨识。
UI线程（主线程）：主线程通过Handle处理发送到主线程的Message，即重写Handle的HandleMessage函数，在其中刷新UI。
所以，但仅通过Thread+Handler实现子线程与主线程之间的交互还不够，如何确保消息队列源源不断的被取出？这里需要 Looper循环去取消息，其实Android中每一个Thread都跟个Looper，Looper可以帮助Thread维护一个消息队列。因此，准确说，应该是Thread+Handler+Looper，三者结合共同实现消息传递机制。
另外，Android为了方便开发，将三者的实现过程整合到AsyncTask中，故AsyncTask可以简单的开启线程并与主线程进行交互。
二、Handler消息（Message）传递机制
Handler具有唯一性，即一旦创建Handler，Handler将与该线程进行绑定，管理该线程的消息队列，因此，Handler主要有两个功能，以主线程中的Handler为例：
1）传递其他线程中的消息进队列。利用handler.sendMessage（）或handler. postMessage()管理消息在队列中的位置
2）队列中的消息与UI交互。利用Handler.HandleMessage（）函数与UI交互。
一个完整的消息传递机制如下图，有三个要素，分别是Message消息，MessageQueue消息队列，Looper循环泵。 Handler负责将子线程的Message进入队列排序确定位置，并将Looper循环泵出来的队首消息与主线程交互。具体过程见下面的源码过程分析。
三、Handler消息传递机制过程源码分析（以Activity主线程为例）
1）创建 new Handler()
Handler()的构造函数如下：
public Handler(Callback callback, boolean async) {
mLooper = Looper.myLooper();
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}所以，创建Handler，即自动绑定了一个Looper以及一个消息队列mQueue，以及一个回调接口Callback（如下），handleMessage（）是一个空函数，承担与UI交互功能，所以需要在主线程中重写。
public interface Callback {
public boolean handleMessage(Message msg);
}2）获取Message（Message是一个final类），Android推荐用Message.obtain()或者Handler.obtainMessage()获取Message
public final Message obtainMessage()
{
return Message.obtain(this);
}obtain(this)，this即为Handler，Message中对应的obtain（）函数如下：
public static Message obtain(Handler h) {
Message m = obtain();
m.target = h;
return m;
}关键是这句，m.target = h，赋值消息传送目标即为该Handler，而obtain()函数如下：如果消息池中不为空，则直接拿来使用，否则创建Message。
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
sPoolSize--;
return m;
}
}
return new Message();
}3）sendMessage或postMessage将Message插入队列恰当位置，但二者最后都是调用函数sendMessageAtTime，并通过enqueueMessage函数将信息Message在mQueue中确定位置、排队。
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}继续寻找源码，发现enqueueMessage最终会调用MessageQueue中的enqueueMessage，即
boolean enqueueMessage(Message msg, long when) {
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked.
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
// Inserted within the middle of the queue. Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue.
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p; // invariant: p == prev.next
prev.next = msg;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
依据处理时间when进行排队，when越小，Message在队列中越靠前。
4）Looper利用循环泵loop（）循环抽取队列中的Message并处理界面交互
public static void loop() {
final MessageQueue queue = me.mQueue;
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
msg.target.dispatchMessage(msg);
}
}分析代码，很容易发现Loop是一个循环，直到消息队列为空退出。若存在Message，则通过msg.target.dispatchMessage(msg)分发消息，看Message源码发现，msg.target即为Handler，所以查看Handler. dispatchMessage(msg)源码如下：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}最终出现handleMessage(msg)，处理与主线程的交互，这需要在主线程中重写。
整个源码过程示意图如下：
四、例子如下
很简单的例子，模拟下载并刷新下载进度及结果
package com.tz.anr;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;
public class MainActivity extends Activity {
protected static final int UPDATE_PROGRESS = 0;
protected static final int UPDATE_FINISH = 1;
private static final int UPDATE_ERROR = 2;
private ProgressBar pb;
private TextView tv_progress;
Handler handler = new Handler(){
public void handleMessage(android.os.Message msg) {
//2.收到子线程发过来的消息
//该方法是执行在主线程里面，所以可以直接操作UI
switch (msg.what) {
case UPDATE_PROGRESS:
int progress = msg.arg1;
//更新进度条
pb.setProgress(progress);
tv_progress.setText(progress+"%");
break;
case UPDATE_FINISH:
Toast.makeText(MainActivity.this, "下载完毕!", 0).show();
break;
case UPDATE_ERROR:
Toast.makeText(MainActivity.this, "下载出错!", 0).show();
break;
default:
break;
}
};
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
pb = (ProgressBar)findViewById(R.id.pb);
pb.setMax(100);
tv_progress = (TextView)findViewById(R.id.tv_porgress);
}
public void click(View v){
/**
* 开子线程：AsyncTask、Thread
* 模拟下载。
*/
try {
new Thread(new Runnable() {
@Override
public void run() {
int progress = 0;
while(progress<100){
try {
Thread.sleep(500);
progress += 10;
//1.子线程里面发送消息给主线程。
// Message msg = new Message();
Message msg = handler.obtainMessage();
//what:代表是谁发出的消息--标识符id
msg.what = UPDATE_PROGRESS;
//存放数据arg1,arg2,obj
// msg.arg2
// msg.obj = new Student();
msg.arg1 = progress;
handler.sendMessage(msg);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// Message msg = handler.obtainMessage();
// //what:代表是谁发出的消息--标识符id
// msg.what = UPDATE_FINISH;
// handler.sendMessage(msg);
Message msg = handler.obtainMessage();
msg.sendToTarget();//这种方法只能使用handler.obtainMessage();
// handler.sendEmptyMessage(UPDATE_FINISH);
// handler.sendMessageDelayed(msg, delayMillis)//delayMillis延迟时间，多久以后发送该消息
// handler.sendMessageAtTime(msg, uptimeMillis)//uptimeMillis:可以在某个时间点发送该消息
}
}).start();
} catch (Exception e) {
e.printStackTrace();
// Message msg = handler.obtainMessage();
// //what:代表是谁发出的消息--标识符id
// msg.what = UPDATE_ERROR;
// handler.sendMessage(msg);
handler.sendEmptyMessage(UPDATE_ERROR);
}
}
}