Handler任务模型之MessageQueue

1. 介绍

在之前的篇幅中介绍了Handler任务模型中Message类和Looper类的源码分析，本篇将分析Handler类和Message类。

2. 源码分析

Handler类

之前 Handler任务模型之Looper类分析得到博乐评论说应该从使用开始到源码分析，这样可以使条理更加清晰，所以咱们先看下Handler的使用

private Handler handler = new Handler() {

public void handleMessage(android.os.Message msg) {
//.................
};
};

Message msg = Message.obtain();
msg.what = 0;
handler.sendMessage(msg);

我们一般是这样使用Handler的，首先谈下Handler的构造，Handler类本身提供了四种构造方法

public Handler() {
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = null;
}

public Handler(Callback callback) {
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
}

public Handler(Looper looper) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = null;
}

public Handler(Looper looper, Callback callback) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
}

四种构造函数主要是为了三个变量赋值，第一个是mLooper，第二个是mQueue，第三个是mCallBack。

其中Looper是一个循环体，MessageQueue保持着Message消息链的引用，mCallBack提供一个回调方法在handlerMessage之前执行。

Handler类本身提供了很多的发送消息的方法和post的方法



这些方法内部最后都是同一调用sendMessageAtTime这个方法

public boolean sendMessageAtTime(Message msg, long uptimeMillis)
{
boolean sent = false;
MessageQueue queue = mQueue;
if (queue != null) {
msg.target = this;
sent = queue.enqueueMessage(msg, uptimeMillis);
}
else {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
}
return sent;
}

第6行:将Message的target赋值为this,可以看出一个Message对应一个Handker，谁发送的消息还要交给谁处理，只是在主线程绕一圈而已

第7行:将msg投递到消息链中

MessageQueue源码分析

handler的sendMessageAtTime方法内部调用MessageQueue的enqueueMessage投递任务

final boolean enqueueMessage(Message msg, long when) {
if (msg.when != 0) {
throw new AndroidRuntimeException(msg
+ " This message is already in use.");
}
if (msg.target == null && !mQuitAllowed) {
throw new RuntimeException("Main thread not allowed to quit");
}
final boolean needWake;
synchronized (this) {
if (mQuiting) {
RuntimeException e = new RuntimeException(
msg.target + " sending message to a Handler on a dead thread");
Log.w("MessageQueue", e.getMessage(), e);
return false;
} else if (msg.target == null) {
mQuiting = true;
}

msg.when = when;
//Log.d("MessageQueue", "Enqueing: " + msg);
Message p = mMessages;
if (p == null || when == 0 || when < p.when) {
msg.next = p;
mMessages = msg;
needWake = mBlocked; // new head, might need to wake up
} else {
Message prev = null;
while (p != null && p.when <= when) {
prev = p;
p = p.next;
}
msg.next = prev.next;
prev.next = msg;
needWake = false; // still waiting on head, no need to wake up
}
}
if (needWake) {
nativeWake(mPtr);
}
return true;
}

第2-5行:通过msg.when对消息进行校验，新消息默认是没有when赋值的，如果此时msg.when != 0说明已经执行该Message正在被使用。不能再次被添加到链表中去

第6-8行:在之前的篇幅中我们介绍过当msg.target为空作为Looper消息循环结束的一个标志位，

mQuitAllowed控制当前线程是否被允许，一般线程是被允许，因为mQuitAllowed初始值为true，但是UI主线程是不允许退出的，因为在Looper的prepareMainLooper方法中将mQuitAllowed赋值为false

public static final void prepareMainLooper() {
prepare();
setMainLooper(myLooper());
if (Process.supportsProcesses()) {
myLooper().mQueue.mQuitAllowed = false;
}
}

第20 - 37行:在Message源码分析中我们可以看出Message是以链表形式存放的，当时不能看出Message之间的关系，其实Message是一个按照时间从小到大的链表形式存放的，这些代码行就是处理这些逻辑关系。

通过上面的步骤已经将Message添加消息链表中，同时Looper的loop方法会一直调用MessageQueue的next取出消息

final Message next() {
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;

for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(mPtr, nextPollTimeoutMillis);

synchronized (this) {
// Try to retrieve the next message.  Return if found.
final long now = SystemClock.uptimeMillis();
final Message msg = mMessages;
if (msg != null) {
final long when = msg.when;
if (now >= when) {
mBlocked = false;
mMessages = msg.next;
msg.next = null;
if (Config.LOGV) Log.v("MessageQueue", "Returning message: " + msg);
return msg;
} else {
nextPollTimeoutMillis = (int) Math.min(when - now, Integer.MAX_VALUE);
}
} else {
nextPollTimeoutMillis = -1;
}

// If first time, then get the number of idlers to run.
if (pendingIdleHandlerCount < 0) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount == 0) {
// No idle handlers to run.  Loop and wait some more.
mBlocked = true;
continue;
}

if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}

// Run the idle handlers.
// We only ever reach this code block during the first iteration.
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler

boolean keep = false;
try {
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf("MessageQueue", "IdleHandler threw exception", t);
}

if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}

// Reset the idle handler count to 0 so we do not run them again.
pendingIdleHandlerCount = 0;

// While calling an idle handler, a new message could have been delivered
// so go back and look again for a pending message without waiting.
nextPollTimeoutMillis = 0;
}

第11-28行:通过判断时间是否符合条件从链表中取出消息，这里时间是按照开机时间计算的

余下的代码行是处理IdleHandler闲时回调接口，以及该回调接口是处理一次即焚还是继续调用的问题，

好像在项目中不是很常用到。

这样从MessageQueue持有的消息链中取出消息后就要回到Looper的loop方法逻辑

public static final void loop() {
Looper me = myLooper();
MessageQueue queue = me.mQueue;

// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();

while (true) {
Message msg = queue.next(); // might block
//if (!me.mRun) {
//    break;
//}
if (msg != null) {
if (msg.target == null) {
// No target is a magic identifier for the quit message.
return;
}
msg.target.dispatchMessage(msg);
msg.recycle();
}
}
}

第16-19行:通过标志位控制Looper的退出

第20行：分发消息msg.target.dispatchMessage(msg);

这样就将消息分发给相应的Handler中，最后回调到我们重写的handleMessage方法中

3. 总结

从以上的分析我们可以看出，各个类之间的对应关系，一个Thread对应一个Looper，一个Looper对应一个MessageQueue,一个MessageQueue持有一个Message消息链，消息链中每个消息对应一个Handler，也就是一个Looper对应对个Handler对象。