Android Handler消息处理顺序分析

看到Handler中的消息处理函数：

1. public void dispatchMessage(Message msg){...}

这个函数是在Looper的执行消息循环loop()的时候取出Message然后执行：

1. msg.target.dispatchMessage(msg);

时，msg对象的target就是这个Handler对象，即执行了Handler的dispatchMessage()函数：

函数定义如下：

1. /**
2. * Handle system messages here.
3. */
4. public void dispatchMessage(Message msg) {
5. if (msg.callback != null) {
6. handleCallback(msg);
7. } else {
8. if (mCallback != null) {
9. if (mCallback.handleMessage(msg)) {
10. return;
11. }
12. }
13. handleMessage(msg);
14. }
15. }

从这个函数中可以看到，执行顺序逻辑是这样的：

1.如果Message对象有CallBack回调的话，就只执行这个回调，然后就结束了。

可见如果要使用Message的CallBack的话，就别在用其他的东西了。其实是个Runnable对象。

例如我们可以这样构建Message的CallBack：

1. Message msgCallback = Message.obtain(myHandler, new Runnable() {
2. @Override
3. public void run() {
4. Log.d(TAG, "msgCallback Runnable run() tid : " + Thread.currentThread().getId());
5. }
6. });

2.else分支下，如果Handler的CallBack对象不为空，那么就执行它的handleMessage()函数。

如果这个函数return true,那么就直接推出了，不会执行下面了。如果return false的话，就继续执行3.

例如我们可以这样来构建一个Handler的CallBack对象：

1. private Handler.Callback callback = new Handler.Callback() {
2. @Override
3. public boolean handleMessage(Message msg) {
4. Log.d(TAG, "Handler.Callback handleMessage msg : " + msg.what);
5. Log.d(TAG, "Handler.Callback handleMessage tid : " + Thread.currentThread().getId());
6. return false;
7. //            return true;
8. }
9. };

3.这才调用到了Handler的handleMessage()函数，也就是我们经常要在子类覆写的这个函数，从中我们可以做消息的处理。

附件中是我的测试Demo，也同时解惑了我的一个疑问，那就是Runnable对象到Handler中执行的时候，是不是另启动了新的线程呢？答案是否定的，这个Runnable对象只是被调用了它的run()方法,就像是一个普通的方法被调用了一样，根本就没有start一个线程，所以这个run()方法也是在Handler所在的线程中被执行的。

这个是handleCallback函数：

1. private static void handleCallback(Message message) {
2. message.callback.run();
3. }

可以看到，只是调用了message对象的Runnable对象的run()函数。

当然，还得分析Handler的post(Runnable r)方法的Runnable对象最终是怎么被执行的，才能彻底解决我的疑问。

这个是Handler的post方法：

1. public final boolean post(Runnable r)
2. {
3. );
4. }

看到把Runnable对象r传到getPostMessage中了。

Handler中的getPostMessage方法：

1. private static Message getPostMessage(Runnable r) {
2. Message m = Message.obtain();
3. m.callback = r;
4. return m;
5. }

可以看到，原来是这样啊。使用了Runnable对象r从Message中obtain()分配出一个Message对象出来，然后调用的是sendMessageDelayed来发送消息。

这就对了，我们自己post的Runnable对象，也不过是放到了Message的Runnable对象中了，也就是Message对象的CallBack了。他有优先执行的权利，事实上，我们如果通过post一个Runnable的话，也没办法修改更多的Message对象的参数信息了，所以只执行到这个Runnable也是合理的。

但是我却几乎没使用过Handler的callback对象，看来这个东西还是可以做优先级的消息过滤的，如果return true的话，就不去继续执行了。这个以后还是要研究研究具体怎么应用场景的啦。