android message handler

1  Android 提供了一套异步处理消息机制；

有提供两套的实现方案：java side和cpp side

 java side：

Handler / Message/Looper/MessageQueue

code 路径：

frameworks/base/core/java/android/os/Looper.java

frameworks/base/core/java/android/os/Message.java

frameworks/base/core/java/android/os/Handler.java

frameworks/base/core/java/android/os/MessageQueue.java

frameworks/base/core/jni/android_os_MessageQueue.cpp

 cpp side--Looper.cpp

code 路径：

system/core/libutils/Looper.cpp

2 简述相关类的功能：

Handler 是消息的处理类，每个message都指定该消息交由谁处理

Message是消息的封装

Looper是消息的马达，（简单说内部有for循环一直做轮询），该类与thread 有关系。

MessageQueue是消息队列的入口

cpp 端Looper: 一个类里面封装了handler/message/消息队列的相关实现。同时向java side 提供wait/poll的逻辑和对fd的监听动作。

4 提供下相关类的图

 

 

 5 详细的调用结构

Handler：--  构造函数中会获取相应的looper

obtainMessage

• Message.obtain

postAtTime

• sendMessageAtTime
  • enqueueMessage
    •  MessageQueue.enqueueMessage

removeMessages

• mQueue.removeMessages

hasMessages

• mQueue.hasMessages

Handler.runWithScissors

如果调用thread不同于handler的thread，会由等待handler thread 执行完成后再通知回来

runWithScissors( Runnable r, long timeout):

• Looper.myLooper() == mLooper
  • r.run();
  • Return
• br= new BlockingRunnable（r）  //这边是再调用thread中处理，new BlockingRunnable
  • br.postAndWait(this, timeout)

BlockingRunnable.postAndWait   :

• handler.post(this)//  这边往handler post自己， handler执行到自己的run方法
• wait(delay)//  调用thread 会wait

BlockingRunnable.run

• mTask.run() // handler thread中执行task的run方法
• notifyAll() //  hanlder thread执行完 notify 调用线程停止wait

Looper.java

Looper.prepare---线程创建后需要调用该方法，初始化相关消息机制

• prepare(boolean quitAllowed)
  • sThreadLocal.set(new Looper(quitAllowed));
    • new MessageQueue
      • nativeInt  --JNI
        • new NativeMessageQueue
          • new Looper.cpp

 Looper.loop()

• myLooper()
• for (;;) {
  • loopOnce
    •  mQueue.next() // 调用MessageQueue的next，里面有wait
    • msg.target.dispatchMessage(msg);
    • msg.recycleUnchecked()

Looper.myLooper().quit()

Looper.myLooper().quitSafely()

• mQueue.quit

MessageQueue

MessageQueue.next

• for (;;) {
  • nativePollOnce(ptr, nextPollTimeoutMillis);
  • 遍历Message
    • msg != null && !msg.isAsynchronous()
    • now < msg.when
      • Set nextPollTimeoutMillis
    • now >= msg.when
      • 更新message queue：pre->next = msg->next
      • msg.markInUse();
      • Return msg
  • mQuitting=true：dispose()

MessageQueue.enqueueMessage

• mQuitting = true: return
• 更新msg： msg.markInUs()   / set when
• 更新message queue：
  • 如果空，设置mMessage
  • 非空：按when 排序，插入到链表中

MessageQueue.hasMessage/removeMessages  都是遍历message 链表的操作

MessageQueue.quit(boolean safe)

• mQuitting=true : return
• Safe=true:  removeAllFutureMessagesLocked
• Safe=false: removeAllMessagesLocked
• nativeWake

MessageQueue.addOnFileDescriptorEventListener

removeOnFileDescriptorEventListener

updateOnFileDescriptorEventListenerLocked

• 都是调用updateOnFileDescriptorEventListenerLocked实现更新操作
• 使用mFileDescriptorRecords[SparseArray]保存相关的fd及event操作，更新创建或删除相关的FileDescriptorRecord
• nativeSetFileDescriptorEvents 更新到native层

MessageQueue.dispatchEvents ---- Called from native code

• record = mFileDescriptorRecords.get(fd);
• listener = record.mListener;
• listener.onFileDescriptorEvents( record.mDescriptor, events);
• newWatchedEvents != oldWatchedEvents  & newWatchedEvents == 0 : mFileDescriptorRecords.removeAt(index)

 Looper.cpp  ---- 真正的驱动类

 Looper 类内部实现了java 层的msg/handler/thread 相关的功能，并且真正有实现wait和wake的功能。

1 Looper 类中定义了一个数据结构vector 存储消息列表。Vector<MessageEnvelope> mMessageEnvelopes;

2 每个thread保证只有一个Looper在跑，通过以下几个linux API实现：

pthread_key_create /pthread_setspecific/pthread_getspecific

3 使用epoll 实现的timeout和监听fd的逻辑: pollOnce epoll_wait

4 wake 使用pipe 的方式，往fd中写data，唤醒epoll的wait逻辑

5 可以addFd 去监听fd的逻辑

epoll_ctl(fd, EPOLL_CTL_ADD/EPOLL_CTL_MOD/EPOLL_CTL_DEL)

6 综述：

1  java side 的message 都是存储在MessageQueue中，MessageQueue里面使用链表的方式将java side msg 连接起来.

2 java side 使用MessageQueue与cpp的Looper 进行绑定，通过Looper实现pollOnce和wake的功能。

3 java side也有监听fd的功能，接口是在MessageQueue中，不过真正实现还是Looper.cpp中，可以使用如下方式

Looper.myLooper().getQueue.addOnFileDescriptorEventListener

4 使用new Handler 的方式创建的handler，其looper对应的thread的是调用new的thread。

5 java side 几个类的关系：

Handler---1：1-----Looper ----1：1----- MessageQueue---1：1---Looper.cpp

MessageQueue  ---- 1： N ---Message  ---1：1-----Handler

所以MessageQueue中的handler 可以是不同的，但handler 必须都是同一个thread的。

6 CPP 层消息机制都是在Looper一个类中定义的，其接口基本直接使用的是linux 接口：epoll_wait/epoll_ctrl/ pthread_create***等，相关功能也比较完善。