消息机制概述
Android的消息机制主要是Handler的消息机制，Handler的运行需要底层的MessageQueue和Looper的支持。
Handler：负责将需要更新界面的子线程切换到主线程。
MessageQueue：消息队列，以队列的形式对外提供插入和删除的工作，其内部结构是以链表的形式存储消息的。
Looper：以无限循环的方式来查找是否有消息，如果有就处理消息，否则就一直等待着。
ThreadLocal：通过ThreadLocal可以在不同线程里互不干扰的存储和提供数据。
由于Android的UI控件是线性不安全的，所以不能再子线程中更新UI，checkThread()检测主线程更新UI，Handler用于解决从子线程切换到主线程更新UI。
void checkThread(){
if(mThread != Thread.currentThread){
throw new CalledFromWrongThreadException("Only the original thread that created a view hierarchy can touch its views.");
}
}
Handler工作过程：
1、Handler的post()讲一个Runnable投递到Handler内部的Looper中去处理。
2、Handler的send()发送一条消息，这条消息会在looper中去处理。
当Handler的send()被调用时，它会调用MessageQueue的enqueueMessage()将消息放入消息队######列，当Looper发现有信息到来时就会处理这个消息，最终消息中的Runnable()或者Handler的######handleMessage()就会被调用。过程如下：
MessageQueue的工作原理
MessageQueue主要包含两个操作：插入和读取。读取本身会伴随着删除。插入和读取对应的方法是enqueueMessage和next，MessageQueue是一个用单链的数据结构来维护消息列表。下面是enqueueMessage()和next()的实现：
boolean enqueueMessage(Message msg, long when){
synchronized(this){
msg.markInUse();
msg.when = when;
Message p = mMessage;
boolean needWake;
if(p == null || when == 0 || when < p.when){
msg.next = p;
mMessage = msg;
needWake = mBlocked;
}else{
needWake = mBlocked && p.target == && msg.isAsynchronous();
Message prev;
for(;;){
prev = p;
p = p.next;
if(p == null || when < p.when){
break;
}
if(needWake && p.isAsychronous()){
needWake = false;
}
}
}
if(needWake){
nativeWake(mPtr);
}
}
return true;
}
Message next(){
int pendingIdleHandlerCount = -1;
int nextPollTimeOutMillis = 0;
for(;;){
if(nextPollTimeOutMillis != 0){
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeOutMillis);
synchronized(this){
......
}
}
}
从enqueueMessage()和next()的实现来看，MessageQueue的队列主要是通过单链表的形式进行插入和移除数据。
Looper的工作原理
Looper会不停的从MessageQueue中查看是否有新消息，有就立刻处理，否则会一直阻塞在那里，它的构造方法中会创建一个MessageQueue，然后将当前线程对象保存起来。
private Looper(boolean quitAllowed){
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
Handler的工作需要Looper，没有Looper的线程就会报错，通过Looper.prepare()为当前线程创建一个Looper，然后通过Looper.loop()来开启消息循环。
new Thread("Thread #2"){
public void run(){
Looper.prepare();
Handler handler = new Handler();
Looper.loop();
}
}
Looper也是可以退出的，Looper提供了quit()和quitSafely()来退出Looper，区别是：quit()直接退出一个Looper，quitSafely()设置一个退出标记，把消息队列中的已有消息处理完毕后才安全退出。如果退出Looper，则该线程终止，建议不需要的时候终止Looper。
Looper最重要的一个方法是loop(),只有调用了loop()后，消息循环系统才会真正的开始执行，下面是loop()源码：
public static final void loop() {
Looper me = myLooper(); //得到当前线程Looper
MessageQueue queue = me.mQueue; //得到当前looper的MQ
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
// 开始循环
while (true) {
Message msg = queue.next(); // 取出message
if (msg != null) {
if (msg.target == null) {
// message没有target为结束信号，退出循环
return;
}
if (me.mLogging!= null) me.mLogging.println(
">>>>> Dispatching to " + msg.target + " "
+msg.callback + ": " + msg.what
);
// 将真正的处理工作交给message的target
msg.target.dispatchMessage(msg);
if (me.mLogging!= null) me.mLogging.println(
"<<<<< Finished to " + msg.target + " " + msg.callback);
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf("Looper", "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+Long.toHexString(newIdent) + " while dispatching to "
+msg.target.getClass().getName() + " "
+msg.callback + " what=" + msg.what);
}
// 回收message资源
msg.recycle();
}
}
}
Looper的loop()是一个死循环，当MessageQueue的next()返回了null时，loop()跳出循环，或者调用Looper的quit().当Looper调用loop()时，Looper就是调用MessageQueue的quit()来通知消息队列退出，此时它的next()返回null。如果MessageQueue的next()返回新消息时，Looper就会处理这条消息：msg.dispatchMessage(msg),这里的msg.target是发送这条消息的Handler对象，这样Handler发送的消息最终又交给它的dispatchMessage()去处理了。但是这里不同的是，Handler的dispatchMessage()是在创建Handler时使用的Looper中执行的，这样就成功的将代码逻辑切换到指定的线程中去执行了。
Handler的工作原理
Handler的工作主要包括发送和接受消息。消息的发送通过post的一系列方法或者send的一系列方法实现。
public final boolean post(Runnable r)
{
// 注意getPostMessage(r)将runnable封装成message
return sendMessageDelayed(getPostMessage(r), 0);
}
private final Message getPostMessage(Runnable r) {
Message m = Message.obtain(); //得到空的message
m.callback = r; //将runnable设为message的callback，
return m;
}
public boolean sendMessageAtTime(Message msg, long uptimeMillis)
{
boolean sent = false;
MessageQueue queue = mQueue;
if (queue != null) {
msg.target = this; // message的target必须设为该handler！
sent = queue.enqueueMessage(msg, uptimeMillis);
}
else {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
}
return sent;
}
Handler发送消息的过程就是向消息队列中插入一条消息，MessageQueue的next()就会返回这条消息给Looper，Looper收到消息后就开始处理了，最终消息有Looper交给Handler处理，即Handler的dispatchMessage()会被调用：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
// 如果message设置了callback，即runnable消息，处理callback！
handleCallback(msg);
} else {
// 如果handler本身设置了callback，则执行callback
if (mCallback != null) {
/* 这种方法允许让activity等来实现Handler.Callback接口，避免了自己编写handler重写handleMessage方法
if (mCallback.handleMessage(msg)) {
return;
}
}
// 如果message没有callback，则调用handler的钩子方法handleMessage
handleMessage(msg);
}
}
// 处理runnable消息
private final void handleCallback(Message message) {
message.callback.run(); //直接调用run方法！
}
// 由子类实现的钩子方法
public void handleMessage(Message msg) {
}
public interface Callback{
public boolean handleMessage(Message msg);
}
Handler处理消息的过程如下：
首先检查Message的callback是否为null，不为null 就通过handleCallBack来处理消息，Message的callback是一个Runnable对象，实际上就是Handler的post()所传递的Runnable参数。
其次检查mCallback是否为null，不为null就调用handleMessage()来处理消息。Callback是个接口.
最后调用Handler的handleMessage()来处理消息。
