在Activity中创建Handler发送消息以及接受消息过程浅析

在Github上：https://github.com/caiqiqi/Notes/blob/master/%E5%9C%A8Activity%E4%B8%AD%E5%88%9B%E5%BB%BAHandler%E5%8F%91%E9%80%81%E6%B6%88%E6%81%AF%E4%BB%A5%E5%8F%8A%E6%8E%A5%E5%8F%97%E6%B6%88%E6%81%AF%E8%BF%87%E7%A8%8B%E6%B5%85%E6%9E%90.md

ActivityThread::main() ->

…

Looper.prepareMainLooper();

public static void prepareMainLooper() {
prepare(false);    // sThreadLocal.set(new Looper(quitAllowed));
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}

/**
* Return the Looper object associated with the current thread.  Returns
* null if the calling thread is not associated with a Looper.
*/
public static Looper myLooper() {
return sThreadLocal.get();
}

private Looper(boolean quitAllowed){
mQueue = new MessageQueue(quitAllowed);
mRun = true;
mThread = Thread.currentThread();
}

…

Looper最重要的一个方法是loop()方法，只有调用了loop后，消息循环系统才会真正地起作用。

public static void loop(){
final Looper me = myLooper();
if (me == null){
throw new RuntimeException("No Loooper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
...
for(;;){
Message msg = queue.next();    //might block
// No message indicates that the message queue is quitting.
return;
}
...
msg.target.dispatchMessage(msg);    //这里的msg.target指的就是发送这条消息的Handler对象，这样Handler发送的消息最终又交给它的dispatchMessage方法来处理了。
//但这里不同的是Handler的dispatchMessage()是在创建Handler时所使用的Looper的Looper.loop()方法中执行的，这样就成功将代码逻辑切换到指定的线程中去执行了。
...
}

那Handler的dispatchMessage()是怎样的呢？

/**
* Subclasses must implement this to receive messages.
*/
public void handleMessage(Message msg) {
}

/**
* 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);    //即最终还是调动handlerMessage()来处理接收到的消息，不过这个方法得创建Handler时由程序员自己复写。
}
}

当在Activity中

private Handler handler = new Handler();

时，

public Handler(){
...
mLooper = Looper.myLooper();    //取出由ActivityThread类的main()中prepare(false)之后存储在sThreadLocal中的mLooper对象，然后赋值给Handler对象的mLooper，即，拿到与主线程关联的Looper对象
mQueue = mLooper.mQueue;    //将mLooper中的mQueue(MessageQueue)对象赋值给Handler对象的mQueue，之后Handler就可以把发送的消息存储在这个MessageQueue之中
mCallback = null;
}

在Activity中调用handler对象的

handler.sendMessage(...)

;

最终调用的是：

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;    //也就是说，这个消息是发送给Handler这个对象自己的！！！
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);    //作用就是往消息队列中插入一条消息(单链表的插入操作)
}