源码分析：Android消息处理机制
Android消息处理机制主要指的是Handler的运行机制以及它和Looper、MessageQuene协同工作的过程。本篇文章将由浅入深，从源码角度分析整体的运行机制。
简介
Handler 主要是发送消息和处理消息，sendMessage（）和handleMessage()
Handler是Android消息机制的上层接口，这使得开发者只需要处理和Handler的交互即可。在子线程中进行耗时操作，在主线程中刷新UI,这是我们使用Handler的典型案例。 以下就是我们最常见的使用Handler的一种写法：
public class Activity extends android.app.Activity {
private Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
// 进行刷新UI的操作
}
};
@Override
public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
super.onCreate(savedInstanceState, persistentState);
setContentView(R.layout.activity_main);
new Thread(new Runnable() {
@Override
public void run() {
// 在这里进行耗时操作
....
....
Message message = Message.obtain();
message.what = 1;
mHandler.sendMessage(message);
}
}).start();
}
}
Message 需要传递的消息
MessageQueue 消息队列 每次我们调用mHandler.sendMessage(message)后，message都是存在MessageQueue中。MessageQueue只负责存储消息，并不能处理消息，要借助Looper来实现。
Looper 消息轮询器 它会以无限循环的方式去MessageQueue中查找是否有新的消息，有的话就进行处理，没有的话就等待。
运行机制
示意图.png
整个机制大致是这样的：在子线程中Handler调用了sendMessage()方法后，实际上是调用了MessageQueue的enqueueMessage方法，当Looper.loop()执行完后，无限循环当前消息队列中是否有新消息 queue.next(),紧接着调用了当前Handler对象的dispatchMessage()方法，之后dispatchMessage()方法里做的操作是调用了当前Handler的handleMessage()方法，实现了消息的分发。
源码分析
Handler
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
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);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
// 调用MessageQueue的enqueueMessage方法
return queue.enqueueMessage(msg, uptimeMillis);
}
我们可以看到，当我们代码执行了mHandler.sendMessage()语句的时候，实际上是调用了Handler的enqueueMessage方法，方法内部最终调用了MessageQueue的enqueueMessage方法，我们去MessageQueue的enqueueMessage方法看一下：
MessageQueue
boolean enqueueMessage(Message msg, long when) {
// 判断target是不是null
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
// 判断有没有在使用中
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
// 同步锁
synchronized (this) {
// 正在退出时，进行消息的回收
if (mQuitting) {
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w(TAG, e.getMessage(), e);
msg.recycle();
return false;
}
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
// 第一次进来添加到消息列表中，或者当前时间小于message的时间
if (p == null || when == 0 || when < p.when) {
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
//将消息按时间顺序插入到MessageQueue
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;
}
看完上面的enqueueMessage的代码，我们发现，MessageQueue类并没有对消息进行处理，仅仅是做了消息的存储工作，这也跟我们上面的简介中的结论一致。
Looper
当我们把消息存在MessageQueue中，需要Looper去帮助我们不断地去获取消息,通过调用Looper.loop()方法去不断的获取消息，先拿到当前looper的MessageQueue的对象，之后无限循环去消息队列获取消息（ Message msg = queue.next()这行代码）
/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the loop.
*/
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
// 拿到当前looper的MessageQueue对象
final MessageQueue queue = me.mQueue;
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
// 死循环
for (;;) {
// 关键代码，不断的去获取消息
Message msg = queue.next();
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
.....
.....
.....
try {
// target就是绑定的Handler
msg.target.dispatchMessage(msg);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
......
......
......
msg.recycleUnchecked();
}
}
看到这里大致明白了，loop()方法里不断的去获取消息队列中的消息，之后调用了Handler的dispatchMessage()方法。 我们看看dispatchMessage()做了哪些操作：
/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
private static void handleCallback(Message message) {
message.callback.run();
}
第一个if语句判断了消息是否存在回调方法，存在的话执行handleCallback()方法，接着执行回调run方法。当Handler的mCallback不为空时，则回调方法mCallback.handleMessage(msg)； 最后调用Handler自身的回调方法handleMessage()，该方法默认为空，Handler子类通过覆写该方法来完成具体的逻辑。
