android 消息机制

一、Android应用程序的主线程主要用于更新UI界面，并且主线程不能做耗时操作，否则会引起ANR；这种情况下需要开一个子线程来进行耗时操作，动作完成之后，子线程发消息给主线程通知其更新UI显示，常见方法有：

• Activity.runOnUiThread(Runnable);
• View.post(Runnable);
• View.postDelayed(Runnable, long);
• Handler消息机制。

注:经过看源码，会发现Activity.runOnUiThread(Runnable),View.post(Runnable),View.postDelayed(Runnable, long)最终本质上会调用到Handler发送消息的方法，如下代码：

Activity.runOnUiThread(Runnable);

 /**
      * Runs the specified action on the UI thread. If the current thread is the UI
      * thread, then the action is executed immediately. If the current thread is
      * not the UI thread, the action is posted to the event queue of the UI thread.
      *
      * @param action the action to run on the UI thread
      */
     public final void runOnUiThread(Runnable action) {
         if (Thread.currentThread() != mUiThread) {
             mHandler.post(action);
         } else {
             action.run();
         }
     }

View.Post(Runnable),View.PostDelayed(Runnable); 请忽略attachInfo判断。

 public boolean post(Runnable action) {
         final AttachInfo attachInfo = mAttachInfo;
         if (attachInfo != null) {
             return attachInfo.mHandler.post(action);
         }
         // Assume that post will succeed later
         ViewRootImpl.getRunQueue().post(action);
         return true;
     }

 public boolean postDelayed(Runnable action, long delayMillis) {
         final AttachInfo attachInfo = mAttachInfo;
         if (attachInfo != null) {
             return attachInfo.mHandler.postDelayed(action, delayMillis);
         }
         // Assume that post will succeed later
         ViewRootImpl.getRunQueue().postDelayed(action, delayMillis);
         return true;
     }

二、弄清消息机制之前，提一个问题：如何在子线程实例化一个Handler发送message呢？代码很简单，如下

 new Thread(){

             @Override
             public void run() {
                 super.run();
                 Looper.prepare();
                 new Handler().sendEmptyMessage(1);
                 Looper.loop();
             }

 }.start();

接下来，问题又来了：

1.发消息的时候为什么要调用Looper.prepare()；

2.消息发送后为什么要调用Looper.loop()；

3.为什么在主线程里发送信息，我们没有调用 这两个方法呢？

在解答这三个问题之前，先看一张图，大致了解一下消息机制是如何运行的？如下图：

总结一下上面那个图片：在UI线程中有一个消息队列MessageQueue，其它线程do something之后，在UI线程中的消息队列MessageQueue插入Message，而Looper负责轮循消息队列MessageQueue。然后来回答上面第1个问题，看代码：

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

 //初始化Looper，并且初始化消息队列
 private Looper(boolean quitAllowed) {
         mQueue = new MessageQueue(quitAllowed);
         mThread = Thread.currentThread();
  }

通过上图可得知，接收一个消息的前提是，该线程得拥有自己的消息队列MessageQueue，而第1个问题的答案就是创建一个该线程接收消息的一个消息队列。然后第二个问题请看以下代码：

 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.recycleUnchecked();
         }
  }

通过上图可知消息机制中除了消息队列MessageQueue，还得有轮循，第二个问题就是执行轮循的操作。第三个问题请往下看代码：

 public final class ActivityThread {
     ......

     public static final void main(String[] args) {
         ......
         //将当前线程初始化为Looper线程。最终会调用Looper.prepare()
         Looper.prepareMainLooper();

         ......
         // 开始循环处理消息队列
         Looper.loop();

         ......
     }
 }

第三个问题的答案：android应用程序启动过程中，会在进程中执行ActivityThread中main方法，来初始化该应用中UI线程的Looper。这也就是为什么主线程里可以直接调用Handler，而子线程不能直接调用Handler发送消息。

参考：http://3dobe.com/archives/74/