Android应用程序消息处理机制（Looper、Handler）分析（5）

2021-11-02 05:54:39

      ActivityThread类的这个mH成员变量是什么时候创建的呢？我们前面在分析应用程序的消息循环时，说到当应用程序进程启动之后，就会加载ActivityThread类的main函数里面，在这个main函数里面，在通过Looper类进入消息循环之前，会在当前进程中创建一个ActivityThread实例：

  1. public final class ActivityThread {  
  2.     ......  
  3.   
  4.     public static final void main(String[] args) {  
  5.         ......  
  6.   
  7.         ActivityThread thread = new ActivityThread();  
  8.         thread.attach(false);  
  9.   
  10.         ......  
  11.     }  
  12. }  

 在创建这个实例的时候，就会同时创建其成员变量mH了：

  1. public final class ActivityThread {  
  2.     ......  
  3.   
  4.     final H mH = new H();  
  5.   
  6.     ......  
  7. }   

  前面说过，H类继承于Handler类，因此，当创建这个H对象时，会调用Handler类的构造函数，这个函数定义在frameworks/base/core/java/android/os/Handler.java文件中：

  1. public class Handler {  
  2.     ......  
  3.   
  4.     public Handler() {  
  5.         ......  
  6.   
  7.         mLooper = Looper.myLooper();  
  8.         ......  
  9.   
  10.         mQueue = mLooper.mQueue;  
  11.         ......  
  12.     }  
  13.   
  14.   
  15.     final MessageQueue mQueue;  
  16.     final Looper mLooper;  
  17.     ......  
  18. }  

   在Hanlder类的构造函数中，主要就是初始成员变量mLooper和mQueue了。这里的myLooper是Looper类的静态成员函数，通过它来获得一个Looper对象，这个Looper对象就是前面我们在分析消息循环时，在ActivityThread类的main函数中通过Looper.prepareMainLooper函数创建的。Looper.myLooper函数实现在frameworks/base/core/java/android/os/Looper.java文件中：

  1. public class Looper {  
  2.     ......  
  3.   
  4.     public static final Looper myLooper() {  
  5.         return (Looper)sThreadLocal.get();  
  6.     }  
  7.   
  8.     ......  
  9. }  

  有了这个Looper对象后，就可以通过Looper.mQueue来访问应用程序的消息队列了。

 

        有了这个Handler对象mH后，就可以通过它来往应用程序的消息队列中加入新的消息了。回到前面的queueOrSendMessage函数中，当它准备好了一个Message对象msg后，就开始调用mH.sendMessage函数来发送消息了，这个函数定义在frameworks/base/core/java/android/os/Handler.java文件中：

  1. public class Handler {  
  2.     ......  
  3.   
  4.     public final boolean sendMessage(Message msg)  
  5.     {  
  6.         return sendMessageDelayed(msg, 0);  
  7.     }  
  8.   
  9.     public final boolean sendMessageDelayed(Message msg, long delayMillis)  
  10.     {  
  11.         if (delayMillis < 0) {  
  12.             delayMillis = 0;  
  13.         }  
  14.         return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);  
  15.     }  
  16.   
  17.     public boolean sendMessageAtTime(Message msg, long uptimeMillis)  
  18.     {  
  19.         boolean sent = false;  
  20.         MessageQueue queue = mQueue;  
  21.         if (queue != null) {  
  22.             msg.target = this;  
  23.             sent = queue.enqueueMessage(msg, uptimeMillis);  
  24.         }  
  25.         else {  
  26.             ......  
  27.         }  
  28.         return sent;  
  29.     }  
  30.   
  31.     ......  
  32. }  

 

 

   在发送消息时，是可以指定消息的处理时间的，但是通过sendMessage函数发送的消息的处理时间默认就为当前时间，即表示要马上处理，因此，从sendMessage函数中调用sendMessageDelayed函数，传入的时间参数为0，表示这个消息不要延时处理，而在sendMessageDelayed函数中，则会先获得当前时间，然后加上消息要延时处理的时间，即得到这个处理这个消息的绝对时间，然后调用sendMessageAtTime函数来把消息加入到应用程序的消息队列中去。

 

        在sendMessageAtTime函数，首先得到应用程序的消息队列mQueue，这是在Handler对象构造时初始化好的，前面已经分析过了，接着设置这个消息的目标对象target，即这个消息最终是由谁来处理的：



  1. msg.target = this;   


 


   这里将它赋值为this，即表示这个消息最终由这个Handler对象来处理，即由ActivityThread对象的mH成员变量来处理。


 


 


 


        函数最后调用queue.enqueueMessage来把这个消息加入到应用程序的消息队列中去，这个函数实现在frameworks/base/core/java/android/os/MessageQueue.java文件中：


    

  1. public class MessageQueue {  
    2. 

  2.     ......  
    3. 

  3.   
    4. 

  4.     final boolean enqueueMessage(Message msg, long when) {  
    5. 

  5.         ......  
    6. 

  6.   
    7. 

  7.         final boolean needWake;  
    8. 

  8.         synchronized (this) {  
    9. 

  9.             ......  
    10. 

  10.   
    11. 

  11.             msg.when = when;  
    12. 

  12.             //Log.d("MessageQueue", "Enqueing: " + msg);  
    13. 

  13.             Message p = mMessages;  
    14. 

  14.             if (p == null || when == 0 || when < p.when) {  
    15. 

  15.                 msg.next = p;  
    16. 

  16.                 mMessages = msg;  
    17. 

  17.                 needWake = mBlocked; // new head, might need to wake up  
    18. 

  18.             } else {  
    19. 

  19.                 Message prev = null;  
    20. 

  20.                 while (p != null && p.when <= when) {  
    21. 

  21.                     prev = p;  
    22. 

  22.                     p = p.next;  
    23. 

  23.                 }  
    24. 

  24.                 msg.next = prev.next;  
    25. 

  25.                 prev.next = msg;  
    26. 

  26.                 needWake = false; // still waiting on head, no need to wake up  
    27. 

  27.             }  
    28. 

  28.   
    29. 

  29.         }  
    30. 

  30.         if (needWake) {  
    31. 

  31.             nativeWake(mPtr);  
    32. 

  32.         }  
    33. 

  33.         return true;  
    34. 

  34.     }  
    35. 

  35.   
    36. 

  36.     ......  
    37. 

  37. }  
    38. 



 


   把消息加入到消息队列时，分两种情况，一种当前消息队列为空时，这时候应用程序的主线程一般就是处于空闲等待状态了，这时候就要唤醒它，另一种情况是应用程序的消息队列不为空，这时候就不需要唤醒应用程序的主线程了，因为这时候它一定是在忙着处于消息队列中的消息，因此不会处于空闲等待的状态。


 第一种情况比较简单，只要把消息放在消息队列头就可以了：


    

  1. msg.next = p;  
    2. 

  2. mMessages = msg;  
    3. 

  3. needWake = mBlocked; // new head, might need to wake up  
    4. 



第二种情况相对就比较复杂一些了，前面我们说过，当往消息队列中发送消息时，是可以指定消息的处理时间的，而消息队列中的消息，就是按照这个时间从小到大来排序的，因此，当把新的消息加入到消息队列时，就要根据它的处理时间来找到合适的位置，然后再放进消息队列中去：


    

  1. Message prev = null;  
    2. 

  2. while (p != null && p.when <= when) {  
    3. 

  3.     prev = p;  
    4. 

  4.     p = p.next;  
    5. 

  5. }  
    6. 

  6. msg.next = prev.next;  
    7. 

  7. prev.next = msg;  
    8. 

  8. needWake = false; // still waiting on head, no need to wake up  
    9. 



把消息加入到消息队列去后，如果应用程序的主线程正处于空闲等待状态，就需要调用natvieWake函数来唤醒它了，这是一个JNI方法，定义在frameworks/base/core/jni/android_os_MessageQueue.cpp文件中：


    

  1. static void android_os_MessageQueue_nativeWake(JNIEnv* env, jobject obj, jint ptr) {  
    2. 

  2.     NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);  
    3. 

  3.     return nativeMessageQueue->wake();  
    4. 

  4. }  
    5. 



这个JNI层的NativeMessageQueue对象我们在前面分析消息循环的时候创建好的，保存在Java层的MessageQueue对象的mPtr成员变量中，这里把它取回来之后，就调用它的wake函数来唤醒应用程序的主线程，这个函数也是定义在frameworks/base/core/jni/android_os_MessageQueue.cpp文件中：


    

  1. void NativeMessageQueue::wake() {  
    2. 

  2.     mLooper->wake();  
    3. 

  3. }  
    4. 



 这里它又通过成员变量mLooper的wake函数来执行操作，这里的mLooper成员变量是一个C++层实现的Looper对象，它定义在frameworks/base/libs/utils/Looper.cpp文件中：


    

  1. void Looper::wake() {  
    2. 

  2.     ......  
    3. 

  3.   
    4. 

  4.     ssize_t nWrite;  
    5. 

  5.     do {  
    6. 

  6.         nWrite = write(mWakeWritePipeFd, "W", 1);  
    7. 

  7.     } while (nWrite == -1 && errno == EINTR);  
    8. 

  8.   
    9. 

  9.     .......  
    10. 

  10. }  
    11. 



  这个wake函数很简单，只是通过打开文件描述符mWakeWritePipeFd往管道的写入一个"W"字符串。其实，往管道写入什么内容并不重要，往管道写入内容的目的是为了唤醒应用程序的主线程。前面我们在分析应用程序的消息循环时说到，当应用程序的消息队列中没有消息处理时，应用程序的主线程就会进入空闲等待状态，而这个空闲等待状态就是通过调用这个Looper类的pollInner函数来进入的，具体就是在pollInner函数中调用epoll_wait函数来等待管道中有内容可读的。


 


        这时候既然管道中有内容可读了，应用程序的主线程就会从这里的Looper类的pollInner函数返回到JNI层的nativePollOnce函数，最后返回到Java层中的MessageQueue.next函数中去，这里它就会发现消息队列中有新的消息需要处理了，于就会处理这个消息。
















本文转自 Luoshengyang 51CTO博客，原文链接：http://blog.51cto.com/shyluo/966601，如需转载请自行联系原作者
上一篇：Android的UI设计与后台线程交互

下一篇：这个阿里程序员，干了件很轴的事儿