Handler（二）Native实现

本文基于Android9.0源码

引言

通过上一篇Handler（一）源码解析，我们对Handler已经有了一定的了解，我们再深入分析一下Handler Native实现。

frameworks/base/core/jni/android_os_MessageQueue.cpp
frameworks/base/core/jni/android_os_MessageQueue.h
system/core/libutils/Looper.cpp
system/core/include/utils/Looper.h

初始化流程

1、通过MessageQueue的构造方法，调用nativeInit(),调用到android_os_MessageQueue_nativeInit()方法，生成NativeMessageQueue对象。

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

2、NativeMessageQueue()获取Looper对象，首次创建Looper为null，调用构造方法。

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

3、调用系统函数eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC)获取文件描述符，并触发调用rebuildEpollLocked()。

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

4、调用epoll_create(EPOLL_SIZE_HINT)，创建epoll对象；
通过epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeEventFd, & eventItem)添加监听。

void Looper::rebuildEpollLocked() {
    ········
    // Allocate the new epoll instance and register the wake pipe.
    mEpollFd = epoll_create(EPOLL_SIZE_HINT);
    LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance: %s", strerror(errno));

    struct epoll_event eventItem;
    memset(& eventItem, 0, sizeof(epoll_event)); // zero out unused members of data field union
    eventItem.events = EPOLLIN;
    eventItem.data.fd = mWakeEventFd;
    int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeEventFd, & eventItem);
    ········
}

处理消息流程

1、Looper.loop()阻塞

（1）通过android_os_MessageQueue_nativePollOnce()调用到自己的pollOnce()；然后调用mLooper.pollOnce().

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

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

}

（2）在pollOnce()中调用pollInner()方法。

int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
    int result = 0;
    ········
    for (;;) {
        if (result != 0) {
            if (outFd != NULL) *outFd = 0;
            if (outEvents != NULL) *outEvents = 0;
            if (outData != NULL) *outData = NULL;
            return result;
        }
        result = pollInner(timeoutMillis);
    }
}

（3）通过epoll_wait()开始阻塞

int Looper::pollInner(int timeoutMillis) {
    ········
    // Adjust the timeout based on when the next message is due.
    if (timeoutMillis != 0 && mNextMessageUptime != LLONG_MAX) {
        nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
        int messageTimeoutMillis = toMillisecondTimeoutDelay(now, mNextMessageUptime);
        if (messageTimeoutMillis >= 0
            && (timeoutMillis < 0 || messageTimeoutMillis < timeoutMillis)) {
            timeoutMillis = messageTimeoutMillis;
        }
    }
    ········
    struct epoll_event eventItems[EPOLL_MAX_EVENTS];
    int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);
    ········
}

2、唤醒

（1）超时唤醒（延时消息）
当通过epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis)阻塞线程时，需要传入timeoutMillis。而这个timeoutMillis是根据下个消息计算出来的，当延时消息需要执行时，epoll_wait超时，解除阻塞。

（2）主动唤醒（新即时消息）
线程会在pollInner()中通过epoll机制阻塞，当向列表中添加消息时，会计算消息的更新时间，如果需要立即处理，则会调用nativeWake()方法唤醒阻塞。

通过系统函数write(mWakeEventFd, &inc, sizeof(uint64_t))向mWakeEventFd中写入数据，触发epoll的监听。

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

void Looper::wake() {
    uint64_t inc = 1;
    ssize_t nWrite = TEMP_FAILURE_RETRY(write(mWakeEventFd, &inc, sizeof(uint64_t)));
    if (nWrite != sizeof(uint64_t)) {
        if (errno != EAGAIN) {
            LOG_ALWAYS_FATAL("Could not write wake signal to fd %d: %s",mWakeEventFd, strerror(errno));
        }
    }
}

关于epoll的了解，推荐文章

1、 select、poll、epoll之间的区别总结
2、如果这篇文章说不清epoll的本质，那就过来掐死我吧!