详细解读Android Handler中Native挂起唤醒逻辑实现

简述

如果没有阅读过上篇Handler机制解析的，可以先翻看上篇wiki：
https://blog.csdn.net/luoluofeixia/article/details/107544100
我们知道MessageQueue中，每次在next()，取message的时候，如果没有message了，他就会处于挂起状态（这样做的目的），当有消息到来，或者下一个消息的时间到达之后，都会唤醒线程，那么这个是如何实现的呢。

挂起线程

jni方法Java层定义

private native void nativePollOnce(long ptr, int timeoutMillis);

看看jni层实现:
文件：/frameworks/base/core/jni/android_os_MessageQueue.cpp

static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,
        jlong ptr, jint timeoutMillis) {
    NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
    nativeMessageQueue->pollOnce(env, obj, timeoutMillis);
}

我们先看一下这个ptr参数的由来，就在MessageQueue的构造方法里

MessageQueue(boolean quitAllowed) {
    mQuitAllowed = quitAllowed;
    mPtr = nativeInit();
}

看一下nativeInit的实现，同样在android_os_MessageQueue.cpp文件中：

static jlong android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) {
    NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();
    if (!nativeMessageQueue) {
        jniThrowRuntimeException(env, "Unable to allocate native queue");
        return 0;
    }

    nativeMessageQueue->incStrong(env); // 增加强引用（不了解智能指针的同学，可以自行阅读）
    return reinterpret_cast<jlong>(nativeMessageQueue); // 返回nativeMessageQueue的指针给上层
}

首先我们看到最后一行代码，就是将生成nativeMessageQueue的指针返回给上层（ptr），这样上层就可以通过返回的ptr对应到底层的调用。
我们再看一下NativeMessageQueue的构造函数：

NativeMessageQueue::NativeMessageQueue() :
        mPollEnv(NULL), mPollObj(NULL), mExceptionObj(NULL) {
    mLooper = Looper::getForThread();
    if (mLooper == NULL) {
        mLooper = new Looper(false);
        Looper::setForThread(mLooper);
    }
}

构造函数里面，实现很简单，会向线程里面写一个局部变量，有则写，没有则新建一个，而这个局部变量就是Looper，我们再看看Looper是什么，代码在/system/core/libutils/Looper.cpp：

Looper::Looper(bool allowNonCallbacks) :
        mAllowNonCallbacks(allowNonCallbacks), mSendingMessage(false),
        mPolling(false), mEpollFd(-1), mEpollRebuildRequired(false),
        mNextRequestSeq(0), mResponseIndex(0), mNextMessageUptime(LLONG_MAX) {
    mWakeEventFd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
    LOG_ALWAYS_FATAL_IF(mWakeEventFd < 0, "Could not make wake event fd: %s",
                        strerror(errno));

    AutoMutex _l(mLock);
    rebuildEpollLocked();
}

创建一个eventfd，这个很重要，也就是我们实际每次创建一个Looper 都会创建一个eventfd，所以我们查看/proc/xxx/fd的文件时，就能看到这些fd。
我们看看rebuildEpollLocked，在linux中，我们一般监听fd，都会用到epoll相关函数，rebuildEpollLocked就是相关初始化实现：

void Looper::rebuildEpollLocked() {
   // 如果当前监听fd的句柄创建过，则首先关闭句柄
    if (mEpollFd >= 0) {
        close(mEpollFd);
    }

    // 创建句柄，当然本身创建句柄也会创建fd
    mEpollFd = epoll_create(EPOLL_SIZE_HINT);
    struct epoll_event eventItem;
    memset(& eventItem, 0, sizeof(epoll_event));
    eventItem.events = EPOLLIN;
    eventItem.data.fd = mWakeEventFd;
    // 添加被监听的mWakeEventFd到mEpollFd句柄里
    int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeEventFd, & eventItem);
    // 如果上层还设置其他的文件描述符用于监听，则同样将fd加入到句柄中，这个对应的上层方法是MessageQueue中的addOnFileDescriptorEventListener，这里不展开
    for (size_t i = 0; i < mRequests.size(); i++) {
        const Request& request = mRequests.valueAt(i);
        struct epoll_event eventItem;
        request.initEventItem(&eventItem);

        int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, request.fd, & eventItem);
        if (epollResult < 0) {
            ALOGE("Error adding epoll events for fd %d while rebuilding epoll set: %s",
                  request.fd, strerror(errno));
        }
    }
}

所以初始化的过程，实际上就是生成一个监听eventfd的句柄。至此，初始化的流程我们分析完毕，我们回到构造之后的实现，也就是nativeMessageQueue->pollOnce(env, obj, timeoutMillis)
看一下android_os_MessageQueue.cpp的pollOnce函数：

void NativeMessageQueue::pollOnce(JNIEnv* env, jobject pollObj, int timeoutMillis) {
    mPollEnv = env;
    mPollObj = pollObj;
    mLooper->pollOnce(timeoutMillis);
    mPollObj = NULL;
    mPollEnv = NULL;

    if (mExceptionObj) {
        env->Throw(mExceptionObj);
        env->DeleteLocalRef(mExceptionObj);
        mExceptionObj = NULL;
    }
}

同样调用到/system/core/libutils/Looper.cpp的pollOnce方法：

int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
    int result = 0;
    for (;;) {
        while (mResponseIndex < mResponses.size()) {
            const Response& response = mResponses.itemAt(mResponseIndex++);
            int ident = response.request.ident;
            if (ident >= 0) {
                int fd = response.request.fd;
                int events = response.events;
                void* data = response.request.data;
                if (outFd != NULL) *outFd = fd;
                if (outEvents != NULL) *outEvents = events;
                if (outData != NULL) *outData = data;
                return ident;
            }
        }

        if (result != 0) { // 如果上一次循环获得的result不为0，则退出循环
            if (outFd != NULL) *outFd = 0;
            if (outEvents != NULL) *outEvents = 0;
            if (outData != NULL) *outData = NULL;
            return result;
        }

        result = pollInner(timeoutMillis);
    }
}

其中mResponses都是由执行pollInner之后产生的，所以我们优先看pollInner函数：

int Looper::pollInner(int timeoutMillis) {
    // Poll.
    int result = POLL_WAKE; // 默认返回POLL_WAKE即表示需要触发线程唤醒
    mResponses.clear();
    mResponseIndex = 0;

    // We are about to idle.
    mPolling = true;

    struct epoll_event eventItems[EPOLL_MAX_EVENTS];
    // 监听mEpollFd，也就是说一旦mWakeEventFd发生事件通知，或者超时该方法才会返回
    int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);

    // No longer idling.
    mPolling = false;

    // Acquire lock.
    mLock.lock();

    // 如果需要重建epoll，则进行重建，也就是前面提到的rebuildEpollLocked() 方法
    if (mEpollRebuildRequired) {
        mEpollRebuildRequired = false;
        rebuildEpollLocked();
        goto Done;
    }

    // epoll返回的事件数量<0，则认为是错误
    if (eventCount < 0) {
        if (errno == EINTR) {
            goto Done;
        }
        result = POLL_ERROR;
        goto Done;
    }

    // epoll返回的事件数量为0，表示超时错误
    if (eventCount == 0) {
        result = POLL_TIMEOUT;
        goto Done;
    }

    // 循环遍历返回的事件
    for (int i = 0; i < eventCount; i++) {
        int fd = eventItems[i].data.fd;
        uint32_t epollEvents = eventItems[i].events;
        if (fd == mWakeEventFd) {
            // 如果是mWakeEventFd，则表示当前未唤醒事件
            if (epollEvents & EPOLLIN) {
                awoken(); // 清空mWakeEventFd中的值
            } 
        } else {
            // 如果返回的事件不是mWakeEventFd监听唤醒的fd
            ssize_t requestIndex = mRequests.indexOfKey(fd);
            if (requestIndex >= 0) {
                int events = 0;
                if (epollEvents & EPOLLIN) events |= EVENT_INPUT;
                if (epollEvents & EPOLLOUT) events |= EVENT_OUTPUT;
                if (epollEvents & EPOLLERR) events |= EVENT_ERROR;
                if (epollEvents & EPOLLHUP) events |= EVENT_HANGUP;
              // 返回结果放到mResponses中
                pushResponse(events, mRequests.valueAt(requestIndex));
            }
        }
    }
Done: ;

   
    mNextMessageUptime = LLONG_MAX;
    // 处理mMessageEnvelopes消息，这个消息是通过执行Looper::sendMessageAtTime方法增加的本地消息
    while (mMessageEnvelopes.size() != 0) {
        nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
        const MessageEnvelope& messageEnvelope = mMessageEnvelopes.itemAt(0);
        if (messageEnvelope.uptime <= now) {
            { // obtain handler
                sp<MessageHandler> handler = messageEnvelope.handler;
                Message message = messageEnvelope.message;
                mMessageEnvelopes.removeAt(0);
                mSendingMessage = true;
                mLock.unlock();

                handler->handleMessage(message);
            } // release handler

            mLock.lock();
            mSendingMessage = false;
            result = POLL_CALLBACK;
        } else {
            mNextMessageUptime = messageEnvelope.uptime;
            break;
        }
    }

    mLock.unlock();

     // 遍历返回事件中mResponses的回调
    for (size_t i = 0; i < mResponses.size(); i++) {
        Response& response = mResponses.editItemAt(i);
        if (response.request.ident == POLL_CALLBACK) {
            int fd = response.request.fd;
            int events = response.events;
            void* data = response.request.data;
            int callbackResult = response.request.callback->handleEvent(fd, events, data);
            if (callbackResult == 0) {
                removeFd(fd, response.request.seq);
            }
            response.request.callback.clear(); // 清空response的回调方法
            result = POLL_CALLBACK;  // 回调给监听fd的事件
        }
    }
    return result;
}

这里讲到了两种消息类型，我们依次看，显示mMessageEnvelopes，这个是Native消息，我们可以看一下插入Message的方法：

void Looper::sendMessageAtTime(nsecs_t uptime, const sp<MessageHandler>& handler, const Message& message) 

他将一个消息Message，对应一个Handler，通过Looper放到mMessageEnvelopes队列中，是否似曾相识，没错，这其实就是一种类似于java层的MessageQueue、Handler、Looper、Message的实现机制，只是在C++层实现一套类似的机制，与Java层没有任何关系。

由此可见，这个消息是优先级最高的处理的，其次，我们看mResponses消息，这个消息是通过调用注册监听fd增加的一个回调集合，我们看一下增加监听fd的方法，在MessageQueue.java里面有一个方法：

private native static void nativeSetFileDescriptorEvents(long ptr, int fd, int events);

这个方法就会调用到

int Looper::addFd(int fd, int ident, int events, Looper_callbackFunc callback, void* data) {
    return addFd(fd, ident, events, callback ? new SimpleLooperCallback(callback) : NULL, data);
}

我们看一下他的核心实现：

int Looper::addFd(int fd, int ident, int events, const sp<LooperCallback>& callback, void* data) {
    { // 获取锁
        AutoMutex _l(mLock);

       // 生成监听的request
        Request request;
        request.fd = fd;
        request.ident = ident;
        request.events = events;
        request.seq = mNextRequestSeq++;
        request.callback = callback;
        request.data = data;
        if (mNextRequestSeq == -1) mNextRequestSeq = 0; // reserve sequence number -1
        struct epoll_event eventItem;
        request.initEventItem(&eventItem);

        ssize_t requestIndex = mRequests.indexOfKey(fd);
        // 如果没有对应的fd
        if (requestIndex < 0) {
            // 添加增加的fd到mEpollFd句柄里，这也就是为什么监听mEpollFd会获取到这些fd的值的原因
            int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, & eventItem);
            if (epollResult < 0) {
                ALOGE("Error adding epoll events for fd %d: %s", fd, strerror(errno));
                return -1;
            }
            // 将这个fd的request增加到mRequests中，这样就可以实现上面的遍历
            mRequests.add(fd, request);
        } else {
            // 如果有这个fd，尝试增加fd到mEpollFd
            int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_MOD, fd, & eventItem);
            if (epollResult < 0) {
                if (errno == ENOENT) {
                    epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, & eventItem);
                    if (epollResult < 0) {
                        return -1;
                    }
                    scheduleEpollRebuildLocked(); // 
                } else {
                    return -1;
                }
            }
            // 替换原有的request
            mRequests.replaceValueAt(requestIndex, request);
        }
    }
    return 1;
} // 释放锁

void Looper::scheduleEpollRebuildLocked() {
    if (!mEpollRebuildRequired) {
        mEpollRebuildRequired = true; // mEpollRebuildRequired需要重建
        wake(); // 唤醒线程
    }
}

这里的request其实就可以理解为一个回调，当mEpollFd监听到fd的写入时，就可以回调给对应的addFd的LooperCallback方。并且从顺序上看到，这个消息的处理优先级是低于Native的消息的。这个里面的wake()方法，就是用于唤醒线程，scheduleEpollRebuildLocked方法在sendMessageAtTime也有执行，我们下一节仔细解读。

从这个过程我们可以看到，实际上挂起线程的操作，主要由pollInnner这边实现的，通过执行：

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

将线程阻塞，等到mEpollFd监听到消息返回，才会将线程重新运行。

线程唤醒

我们看一下上层MessageQueue.java中的方法：

private native static void nativeWake(long ptr);

同样会走到frameworks/base/core/jni/android_os_MessageQueue.cpp中的：

static void android_os_MessageQueue_nativeWake(JNIEnv* env, jclass clazz, jlong ptr) {
     NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
     nativeMessageQueue->wake();
}
void NativeMessageQueue::wake() {
    mLooper->wake();
}

其实也就是执行到/system/core/libutils/Looper.cpp