[Android] android的消息队列机制

android下的线程，Looper线程，MessageQueue，Handler，Message等之间的关系，以及Message的send/post及Message dispatch的过程。

Looper线程

我 们知道，线程是进程中某个单一顺序的控制流，它是内核做CPU调度的单位。那何为Looper线程呢？所谓Looper线程，即是借助于Looper和 MessageQueue来管理控制流的一类线程。在android系统中，application的主线程即是借助于Looper和 MessageQueue来管理控制流的。其实，不仅仅只有主线程可以用Looper和MessageQueue来管理控制流，其他的线程也一样可以。我 们可以先看一下android source code的注释中给出的一种Looper线程的实现方式：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

package com.example.messagequeuedemo; import android.os.Handler; import android.os.Looper; import android.util.Log; public class LooperThread extends Thread {     public static final String TAG = MainActivity.TAG;     private static final String CompTAG = "<span></span>LooperThread<span></span>";     public Handler mHandler;     @Override     public void run() {         Log.d(TAG, CompTAG + ": LooperThread=>run");         Looper.prepare();         mHandler = new Handler() {             public void handleMessage(android.os.Message msg) {                 Log.d(TAG, CompTAG + ": LooperThread=>Handler=>handleMessage");                 // process incoming message here             }         };         Looper.loop();     } }

可以看到，就是在线程的run()方法中，调用Looper.prepare() 做一些初始化，然后创建一个Handler对象，最后执行Looper.loop()即开始了整个的事件循环。就是这么的简单，一个可以使用消息队列来管 理线程执行流程的Looper 线程就创建好了。

接着我们来看一下，神秘的Looper.prepare()到底都干了些什么事情：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// sThreadLocal.get() will return null unless you've called prepare().  static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>(); /** Initialize the current thread as a looper.   * This gives you a chance to create handlers that then reference   * this looper, before actually starting the loop. Be sure to call   * {@link #loop()} after calling this method, and end it by calling   * {@link #quit()}.   */ public static void prepare() {     prepare(true); } private static void prepare(boolean quitAllowed) {     if (sThreadLocal.get() != null) {         throw new RuntimeException("Only one Looper may be created per thread");     }     sThreadLocal.set(new Looper(quitAllowed)); } private Looper(boolean quitAllowed) {     mQueue = new MessageQueue(quitAllowed);     mRun = true;     mThread = Thread.currentThread(); }

可 以看到，它做的事情就是为当前的线程创建了一个Looper对象，并存储在一个静态的线程局部变量中。在Looper的构造函数中创建了 MessageQueue，同时Looper会引用到当前的线程，并将一个表示状态的变量mRun设置为true。对于此处的线程局部变量 sThreadLocal，可以理解为就是一个HashMap，该HashMap中存放的数据其类型为Looper，而HashMap的key则 Thread.currentThread()。

启动Looper线程就和启动普通的线程一样，比如：

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public class MainActivity extends Activity {     public static final String TAG = "MessageQueueDemo";     private static final String CompTAG = "MainActivity";     private LooperThread mLooperThread;     @Override     protected void onCreate(Bundle savedInstanceState) {         Log.d(TAG, CompTAG + ": MainActivity=>onCreate");         super.onCreate(savedInstanceState);         setContentView(R.layout.activity_main);         mLooperThread = new LooperThread();         mLooperThread.start();     }

同样是new一个Thread对象，然后执行该对象的start()方法。

其实Looper线程有两种，一种就是我们上面看到的那种普通的Looper线 程，另外一种则是main loop线程，创建前者使用我们前面看到的Looper.prepare()方法，而要创建后者，我们则可以使用 Looper.prepareMainLooper()方法。可以看一下Looper.prepareMainLooper()的实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

/**  * Initialize the current thread as a looper, marking it as an  * application's main looper. The main looper for your application  * is created by the Android environment, so you should never need  * to call this function yourself.  See also: {@link #prepare()}  */ public static void prepareMainLooper() {     prepare(false);     synchronized (Looper.class) {         if (sMainLooper != null) {             throw new IllegalStateException("The main Looper has already been prepared.");         }         sMainLooper = myLooper();     } }

比较特别的地方即在于，此处调用prepare()方法传进去的参数为false，即表示这个Looper不能够被quit掉。其他倒是基本一样。整个android系统中，调用到prepareMainLooper()方法的大概有两处：

1 2 3 4

/frameworks/base/services/java/com/android/server/ H A D    SystemServer.java    94 Looper.prepareMainLooper(); /frameworks/base/core/java/android/app/ H A D    ActivityThread.java    5087 Looper.prepareMainLooper();

一处在ServerThread的run()方法中，用于为system server主线程初始化消息队列等，另外一处在ActivityThread的run()方法中，自然即是创建android app主线程的消息队列了。

通过消息与Looper线程交互

那 Looper线程的特别之处究竟在哪里呢？如前所述，这种线程有一个Looper与之关联，这种线程会使用消息队列，或者称为事件循环来管理执行的流程。 那这种特别之处又如何体现呢？其他线程可以向此类线程中丢消息进来，当然此类线程本身也可以往自己的消息队列里面丢消息，然后在事件循环中，这种事件会得 到有效的处理。那究竟要如何往Looper线程的消息队列中发送消息呢？

回忆我们前面创建Looper线程的那个code，我们不是有创建出来一个Handler嘛。没错，我们就是通过Handler来向Looper线程的MessageQueue中发送消息的。可以看一下code的写法。先是LooperThread的写法：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

package com.intel.helloworld; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.util.Log; public class LooperThread extends Thread {     private static final String TAG = MainActivity.TAG;     private static final String CompTAG = "LooperThread";     public Handler mHandler;     @Override     public void run() {         Log.d(TAG, CompTAG + ": " + "LooperThread-->run");         Looper.prepare();         mHandler = new Handler() {             @Override             public void handleMessage(Message msg) {                 // process incoming message                 Log.d(TAG, CompTAG + ": " + "Handler-->handleMessage, msg.what = " + msg.what);             }         };         Looper.loop();     }     public Handler getHandler() {         return mHandler;     } }

然后是向Looper线程发送消息的部分的写法：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99

package com.intel.helloworld; import android.os.Bundle; import android.os.Handler; import android.os.Message; import android.app.Activity; import android.util.Log; import android.view.Menu; public class MainActivity extends Activity {     public static final String TAG = "LifecycleDemoApp";     private static final String CompTAG = "MainActivity";           public static final int MESSAGE_WHAT_CREATE = 1;     public static final int MESSAGE_WHAT_START = 2;     public static final int MESSAGE_WHAT_RESUME = 3;     public static final int MESSAGE_WHAT_PAUSE = 4;     public static final int MESSAGE_WHAT_STOP = 5;     public static final int MESSAGE_WHAT_DESTROY = 6;     LooperThread mThread;     @Override     protected void onCreate(Bundle savedInstanceState) {         Log.d(TAG, CompTAG + ": " + "Activity-->onCreate");         super.onCreate(savedInstanceState);         setContentView(R.layout.activity_main);         mThread = new LooperThread();         mThread.start();     }     @Override     protected void onStart() {         Log.d(TAG, CompTAG + ": " + "Activity-->onStart");         super.onStart();         Handler handler = mThread.mHandler;         Message msg = Message.obtain();         msg.what = MESSAGE_WHAT_START;         handler.sendMessage(msg);     }           @Override     protected void onResume() {         Log.d(TAG, CompTAG + ": " + "Activity-->onResume");         super.onResume();         Handler handler = mThread.mHandler;         Message msg = Message.obtain();         msg.what = MESSAGE_WHAT_RESUME;         handler.sendMessage(msg);     }           @Override     protected void onPause() {         Log.d(TAG, CompTAG + ": " + "Activity-->onPause");         super.onPause();         Handler handler = mThread.mHandler;         Message msg = Message.obtain();         msg.what = MESSAGE_WHAT_PAUSE;         handler.sendMessage(msg);     }           @Override     protected void onStop() {         Log.d(TAG, CompTAG + ": " + "Activity-->onStop");         super.onStop();         Handler handler = mThread.mHandler;         Message msg = Message.obtain();         msg.what = MESSAGE_WHAT_STOP;         handler.sendMessage(msg);     }     @Override     protected void onDestroy() {         Log.d(TAG, CompTAG + ": " + "Activity-->onDestroy");         super.onDestroy();         Handler handler = mThread.mHandler;         Message msg = Message.obtain();         msg.what = MESSAGE_WHAT_DESTROY;         handler.sendMessage(msg);     }     @Override<span style="color:#E53333;"></span> public boolean onCreateOptionsMenu(Menu menu) {         // Inflate the menu; this adds items to the action bar if it is present.         getMenuInflater().inflate(R.menu.main, menu);         return true;     }     @Override     protected void onSaveInstanceState(Bundle outState) {         Log.d(TAG, CompTAG + ": " + "Activity-->onSaveInstanceState");         super.onSaveInstanceState(outState);     } }

向一个Looper线程发送消息的过程，基本上即是，调用Message.obtain()或Handler.obtainMessage()获取一个Message对象->设置Message->调用 Looper线程中创建的Handler对象来发送消息。

Handler 究竟是如何知道要向哪个MessageQueue中发送消息呢，从前面的code中，我们找不到任何将Handler与特定的MessageQueue关 联起来的代码，这究竟是怎么回事呢？这也是我们强调要使用Looper线程中创建的Handler对象来向该Looper线程中发送消息的原因。我们可以 看一下Handler对象构造的过程：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101

/**  * Default constructor associates this handler with the {@link Looper} for the  * current thread.  *  * If this thread does not have a looper, this handler won't be able to receive messages  * so an exception is thrown.  */ public Handler() {     this(null, false); } /**  * Constructor associates this handler with the {@link Looper} for the  * current thread and takes a callback interface in which you can handle  * messages.  *  * If this thread does not have a looper, this handler won't be able to receive messages  * so an exception is thrown.  *  * @param callback The callback interface in which to handle messages, or null.  */ public Handler(Callback callback) {     this(callback, false); } /**  * Use the provided {@link Looper} instead of the default one.  *  * @param looper The looper, must not be null.  */ public Handler(Looper looper) {     this(looper, null, false); } /**  * Use the provided {@link Looper} instead of the default one and take a callback  * interface in which to handle messages.  *  * @param looper The looper, must not be null.  * @param callback The callback interface in which to handle messages, or null.  */ public Handler(Looper looper, Callback callback) {     this(looper, callback, false); } /**  * Use the {@link Looper} for the current thread  * and set whether the handler should be asynchronous.  *  * Handlers are synchronous by default unless this constructor is used to make  * one that is strictly asynchronous.  *  * Asynchronous messages represent interrupts or events that do not require global ordering  * with represent to synchronous messages.  Asynchronous messages are not subject to  * the synchronization barriers introduced by {@link MessageQueue#enqueueSyncBarrier long)}.  *  * @param async If true, the handler calls {@link Message#setAsynchronous(boolean)} for  * each {@link Message} that is sent to it or {@link Runnable} that is posted to it.  *  * @hide  */ public Handler(boolean async) {     this(null, async); } /**  * Use the {@link Looper} for the current thread with the specified callback interface  * and set whether the handler should be asynchronous.  *  * Handlers are synchronous by default unless this constructor is used to make  * one that is strictly asynchronous.  *  * Asynchronous messages represent interrupts or events that do not require global ordering  * with represent to synchronous messages.  Asynchronous messages are not subject to  * the synchronization barriers introduced by {@link MessageQueue#enqueueSyncBarrier long)}.  *  * @param callback The callback interface in which to handle messages, or null.  * @param async If true, the handler calls {@link Message#setAsynchronous(boolean)} for  * each {@link Message} that is sent to it or {@link Runnable} that is posted to it.  *  * @hide  */ public Handler(Callback callback, boolean async) {     if (FIND_POTENTIAL_LEAKS) {         final Class<? extends Handler> klass = getClass();         if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&                 (klass.getModifiers() & Modifier.STATIC) == 0) {             Log.w(TAG, "The following Handler class should be static or leaks might occur: " +                 klass.getCanonicalName());         }     }     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;     mAsynchronous = async; }

可以看到，很简单，是通过Looper.myLooper()获取到当前线程的 Looper对象，并与相关的MessageQueue等关联起来的。这也是前面我们在实现Looper线程时，要在其run方法中创建一个public 的Handler的依据。当然，我们也可以在构造Handler对象时，显式地使其与特定的Looper对象关联起来。

Handler提供了两组函数用于向一个Looper线程的MessageQueue中发送消息，分别是postXXX()族和sendXXX()族。可以先看一下sendXXX()族的实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136

/**  * Pushes a message onto the end of the message queue after all pending messages  * before the current time. It will be received in {@link #handleMessage},  * in the thread attached to this handler.  *    * @return Returns true if the message was successfully placed in to the   *         message queue.  Returns false on failure, usually because the  *         looper processing the message queue is exiting.  */ public final boolean sendMessage(Message msg) {     return sendMessageDelayed(msg, 0); } /**  * Sends a Message containing only the what value.  *    * @return Returns true if the message was successfully placed in to the   *         message queue.  Returns false on failure, usually because the  *         looper processing the message queue is exiting.  */ public final boolean sendEmptyMessage(int what) {     return sendEmptyMessageDelayed(what, 0); } /**  * Sends a Message containing only the what value, to be delivered  * after the specified amount of time elapses.  * @see #sendMessageDelayed(android.os.Message, long)   *   * @return Returns true if the message was successfully placed in to the   *         message queue.  Returns false on failure, usually because the  *         looper processing the message queue is exiting.  */ public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {     Message msg = Message.obtain();     msg.what = what;     return sendMessageDelayed(msg, delayMillis); } /**  * Sends a Message containing only the what value, to be delivered   * at a specific time.  * @see #sendMessageAtTime(android.os.Message, long)  *    * @return Returns true if the message was successfully placed in to the   *         message queue.  Returns false on failure, usually because the  *         looper processing the message queue is exiting.  */ public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {     Message msg = Message.obtain();     msg.what = what;     return sendMessageAtTime(msg, uptimeMillis); } /**  * Enqueue a message into the message queue after all pending messages  * before (current time + delayMillis). You will receive it in  * {@link #handleMessage}, in the thread attached to this handler.  *    * @return Returns true if the message was successfully placed in to the   *         message queue.  Returns false on failure, usually because the  *         looper processing the message queue is exiting.  Note that a  *         result of true does not mean the message will be processed -- if  *         the looper is quit before the delivery time of the message  *         occurs then the message will be dropped.  */ public final boolean sendMessageDelayed(Message msg, long delayMillis) {     if (delayMillis < 0) {         delayMillis = 0;     }     return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); } /**  * Enqueue a message into the message queue after all pending messages  * before the absolute time (in milliseconds) <var>uptimeMillis</var>.  * <b>The time-base is {@link android.os.SystemClock#uptimeMillis}.</b>  * You will receive it in {@link #handleMessage}, in the thread attached  * to this handler.  *   * @param uptimeMillis The absolute time at which the message should be  *         delivered, using the  *         {@link android.os.SystemClock#uptimeMillis} time-base.  *           * @return Returns true if the message was successfully placed in to the   *         message queue.  Returns false on failure, usually because the  *         looper processing the message queue is exiting.  Note that a  *         result of true does not mean the message will be processed -- if  *         the looper is quit before the delivery time of the message  *         occurs then the message will be dropped.  */ 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); } /**  * Enqueue a message at the front of the message queue, to be processed on  * the next iteration of the message loop.  You will receive it in  * {@link #handleMessage}, in the thread attached to this handler.  * <b>This method is only for use in very special circumstances -- it  * can easily starve the message queue, cause ordering problems, or have  * other unexpected side-effects.</b>  *    * @return Returns true if the message was successfully placed in to the   *         message queue.  Returns false on failure, usually because the  *         looper processing the message queue is exiting.  */ public final boolean sendMessageAtFrontOfQueue(Message msg) {     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, 0); } private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {     msg.target = this;     if (mAsynchronous) {         msg.setAsynchronous(true);     }     return queue.enqueueMessage(msg, uptimeMillis); }

绕来绕去，最终都是调用MessageQueue的 enqueueMessage()方法来将一个Message放入一个MessageQueue中。值得注意的是，在 Handler.enqueueMessage()中，会将Message的target设置为this，这实际上是决定了Looper的消息循环中，在 dispatch/handle message时将会使用的Handler。即，在default情况下，处理message的那个handler也将会是发送此message的 handler。

Handler实际的职责，并不像它的名称所显示的那样，其实它不仅仅是处理message，它还负责发送Message给线程的MessageQueue。

再来看一下MessageQueue的enqueueMessage()方法的code：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

boolean enqueueMessage(Message msg, long when) {     if (msg.isInUse()) {         throw new AndroidRuntimeException(msg + " This message is already in use.");     }     if (msg.target == null) {         throw new AndroidRuntimeException("Message must have a target.");     }     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;         }         msg.when = when;         Message p = mMessages;         if (p == null || when == 0 || when < p.when) {             // New head, wake up the event queue if blocked.             msg.next = p;             mMessages = msg;             needWake = mBlocked;         } else {             // Inserted within the middle of the queue.  Usually we don't have to wake             // up the event queue unless there is a barrier at the head of the queue             // and the message is the earliest asynchronous message in the queue.             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;         }     }     if (needWake) {         nativeWake(mPtr);     }     return true; }

整个将Message放入MessageQueue的算法也还算比较清晰简洁，并 没有什么太绕的地方。此处我们可以一览MessageQueue中保存Messages的结构，即，MessageQueue用一个单向链表来保存所有的 Message，而链表中各个Message则按照其请求的执行时间先后来排列。

向Looper 线程的MessageQueue中发送消息的另外一族方法postXXX()，其实现同前面的sendXXX()族方法也大同小异啦：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

/**  * Causes the Runnable r to be added to the message queue.  * The runnable will be run on the thread to which this handler is  * attached.  *  * @param r The Runnable that will be executed.  *  * @return Returns true if the Runnable was successfully placed in to the  *         message queue.  Returns false on failure, usually because the  *         looper processing the message queue is exiting.  */ public final boolean post(Runnable r) {    return  sendMessageDelayed(getPostMessage(r), 0); } private static Message getPostMessage(Runnable r) {     Message m = Message.obtain();     m.callback = r;     return m; }

Post的message，其callback将是传入的Runnable对象，其他就与send的message一样了。

消息队列中消息的处理

消息队列中的消息是在Looper.loop()中被处理的：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

/**  * 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.");     }     final 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();     for (;;) {         Message msg = queue.next(); // might block         if (msg == null) {             // No message indicates that the message queue is quitting.             return;         }         // This must be in a local variable, in case a UI event sets the logger         Printer logging = me.mLogging;         if (logging != null) {             logging.println(">>>>> Dispatching to " + msg.target + " " +                     msg.callback + ": " + msg.what);         }         msg.target.dispatchMessage(msg);         if (logging != null) {             logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);         }         // Make sure that during the course of dispatching the         // identity of the thread wasn't corrupted.         final long newIdent = Binder.clearCallingIdentity();         if (ident != newIdent) {             Log.wtf(TAG, "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);        }         msg.recycle();     } }

这个函数会调用Handler的dispatchMessage()方法来处理消息，其实也就是msg.target对象的dispatchMessage()方法。 此外我们可以看到，在Looper.loop()方法的末尾recycle了从MessageQueue中取出的已经dispatch的消息。从而，我们 需要通过Handler向一个Looper线程的MessageQueue中发送消息时，我们只要obtain一个Message然后发送就好了，而不需 要自己手动去recycle，这些事情将会由Looper来帮助我们完成。接着来看Handler. dispatchMessage()的实现：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

/**  * 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);     } }

在Message的callback成员为非空时，会执行 handleCallback(msg)，否则的话会依据Handler的mCallback是否为空来确定是否要执行 mCallback.handleMessage(msg)，并执行Handler的handleMessage(msg)。Handler的handleMessage()方法通常需要override，来实现消息处理的主要逻辑。而mCallback则使得开发者可以比较容易的添加一种对Message做一些额外检测的机制，以提升消息处理的效率。

接着我们看一下，Handler.handleCallback(msg)的实现：

1 2 3

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