回到MessageQueue函数中，它接下来就是在进入等待状态前，看看有没有IdleHandler是需要执行的：

1. // If first time, then get the number of idlers to run.  
2. if (pendingIdleHandlerCount < 0) {  
3.     pendingIdleHandlerCount = mIdleHandlers.size();  
4. }  
5. if (pendingIdleHandlerCount == 0) {  
6.     // No idle handlers to run.  Loop and wait some more.  
7.     mBlocked = true;  
8.     continue;  
9. }  
10.   
11. if (mPendingIdleHandlers == null) {  
12.     mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];  
13. }  
14. mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers); 

  如果没有，即pendingIdleHandlerCount等于0，那下面的逻辑就不执行了，通过continue语句直接进入下一次循环，否则就要把注册在mIdleHandlers中的IdleHandler取出来，放在mPendingIdleHandlers数组中去。

 

        接下来就是执行这些注册了的IdleHanlder了：

1. // Run the idle handlers.  
2. // We only ever reach this code block during the first iteration.  
3. for (int i = 0; i < pendingIdleHandlerCount; i++) {  
4.       final IdleHandler idler = mPendingIdleHandlers[i];  
5.       mPendingIdleHandlers[i] = null; // release the reference to the handler  
6.   
7.       boolean keep = false;  
8.       try {  
9.             keep = idler.queueIdle();  
10.       } catch (Throwable t) {  
11.             Log.wtf("MessageQueue", "IdleHandler threw exception", t);  
12.       }  
13.   
14.       if (!keep) {  
15.             synchronized (this) {  
16.                     mIdleHandlers.remove(idler);  
17.             }  
18.       }  
19. }  

 执行完这些IdleHandler之后，线程下次调用nativePollOnce函数时，就不设置超时时间了，因为，很有可能在执行IdleHandler的时候，已经有新的消息加入到消息队列中去了，因此，要重置nextPollTimeoutMillis的值：

1. // While calling an idle handler, a new message could have been delivered  
2. // so go back and look again for a pending message without waiting.  
3. nextPollTimeoutMillis = 0;  

  分析完MessageQueue的这个next函数之后，我们就要深入分析一下JNI方法nativePollOnce了，看看它是如何进入等待状态的，这个函数定义在frameworks/base/core/jni/android_os_MessageQueue.cpp文件中：

1. static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,  
2.         jint ptr, jint timeoutMillis) {  
3.     NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);  
4.     nativeMessageQueue->pollOnce(timeoutMillis);  
5. }  

 这个函数首先是通过传进入的参数ptr取回前面在Java层创建MessageQueue对象时在JNI层创建的NatvieMessageQueue对象，然后调用它的pollOnce函数：

1. void NativeMessageQueue::pollOnce(int timeoutMillis) {  
2.     mLooper->pollOnce(timeoutMillis);  
3. }  

这里将操作转发给mLooper对象的pollOnce函数处理，这里的mLooper对象是在C++层的对象，它也是在前面在JNI层创建的NatvieMessageQueue对象时创建的，它的pollOnce函数定义在frameworks/base/libs/utils/Looper.cpp文件中：

1. int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {  
2.     int result = 0;  
3.     for (;;) {  
4.         ......  
5.   
6.         if (result != 0) {  
7.             ......  
8.   
9.             return result;  
10.         }  
11.   
12.         result = pollInner(timeoutMillis);  
13.     }  
14. }  

 为了方便讨论，我们把这个函数的无关部分都去掉，它主要就是调用pollInner函数来进一步操作，如果pollInner返回值不等于0，这个函数就可以返回了。

 

        函数pollInner的定义如下：

1. int Looper::pollInner(int timeoutMillis) {   
2.     ......   
3.    
4.     int result = ALOOPER_POLL_WAKE;   
5.    
6.     ......   
7.    
8. #ifdef LOOPER_USES_EPOLL   
9.     struct epoll_event eventItems[EPOLL_MAX_EVENTS];   
10.     int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);   
11.     bool acquiredLock = false;   
12. #else   
13.     ......   
14. #endif   
15.    
16.     if (eventCount < 0) {   
17.         if (errno == EINTR) {   
18.             goto Done;   
19.         }   
20.    
21.         LOGW("Poll failed with an unexpected error, errno=%d", errno);   
22.         result = ALOOPER_POLL_ERROR;   
23.         goto Done;   
24.     }   
25.    
26.     if (eventCount == 0) {   
27.         ......   
28.         result = ALOOPER_POLL_TIMEOUT;   
29.         goto Done;   
30.     }   
31.    
32.     ......   
33.    
34. #ifdef LOOPER_USES_EPOLL   
35.     for (int i = 0; i < eventCount; i++) {   
36.         int fd = eventItems[i].data.fd;   
37.         uint32_t epollEvents = eventItems[i].events;   
38.         if (fd == mWakeReadPipeFd) {   
39.             if (epollEvents & EPOLLIN) {   
40.                 awoken();   
41.             } else {   
42.                 LOGW("Ignoring unexpected epoll events 0x%x on wake read pipe.", epollEvents);   
43.             }   
44.         } else {   
45.             ......   
46.         }   
47.     }   
48.     if (acquiredLock) {   
49.         mLock.unlock();   
50.     }   
51. Done: ;   
52. #else   
53.     ......   
54. #endif   
55.    
56.     ......   
57.    
58.     return result;   
59. }   

这里，首先是调用epoll_wait函数来看看epoll专用文件描述符mEpollFd所监控的文件描述符是否有IO事件发生，它设置监控的超时时间为timeoutMillis：

1. int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);  

   回忆一下前面的Looper的构造函数，我们在里面设置了要监控mWakeReadPipeFd文件描述符的EPOLLIN事件。

 

        当mEpollFd所监控的文件描述符发生了要监控的IO事件后或者监控时间超时后，线程就从epoll_wait返回了，否则线程就会在epoll_wait函数中进入睡眠状态了。返回后如果eventCount等于0，就说明是超时了：

1. if (eventCount == 0) {  
2.     ......  
3.     result = ALOOPER_POLL_TIMEOUT;  
4.     goto Done;  
5. }  

  如果eventCount不等于0，就说明发生要监控的事件：

1. for (int i = 0; i < eventCount; i++) {  
2.     int fd = eventItems[i].data.fd;  
3.     uint32_t epollEvents = eventItems[i].events;  
4.     if (fd == mWakeReadPipeFd) {  
5.         if (epollEvents & EPOLLIN) {  
6.             awoken();  
7.         } else {  
8.             LOGW("Ignoring unexpected epoll events 0x%x on wake read pipe.", epollEvents);  
9.         }  
10.     } else {  
11.             ......  
12.     }  
13. }  

 这里我们只关注mWakeReadPipeFd文件描述符上的事件，如果在mWakeReadPipeFd文件描述符上发生了EPOLLIN就说明应用程序中的消息队列里面有新的消息需要处理了，接下来它就会先调用awoken函数清空管道中把内容，以便下次再调用pollInner函数时，知道自从上次处理完消息队列中的消息后，有没有新的消息加进来。

 

        函数awoken的实现很简单，它只是把管道中的内容都读取出来：

1. void Looper::awoken() {  
2.     ......  
3.   
4.     char buffer[16];  
5.     ssize_t nRead;  
6.     do {  
7.         nRead = read(mWakeReadPipeFd, buffer, sizeof(buffer));  
8.     } while ((nRead == -1 && errno == EINTR) || nRead == sizeof(buffer));  
9. }  

  因为当其它的线程向应用程序的消息队列加入新的消息时，会向这个管道写入新的内容来通知应用程序主线程有新的消息需要处理了，下面我们分析消息的发送的时候将会看到。

 

        这样，消息的循环过程就分析完了，这部分逻辑还是比较复杂的，它利用Linux系统中的管道（pipe）进程间通信机制来实现消息的等待和处理，不过，了解了这部分内容之后，下面我们分析消息的发送和处理就简单多了。

本文转自 Luoshengyang 51CTO博客，原文链接：http://blog.51cto.com/shyluo/966596，如需转载请自行联系原作者