Android 中Looper机制详解

版本基于：Android R

在《Android 基于Handler 剖析消息机制》一文中，以 Handler 类为起点详细分析了异步通信，分析了Java 端 Handler 与Looper、MessageQueue、Message 之前的通信关系。

框架如下：

在Java 端的 Looper 中会创建一个 Java 端的 MessageQueue实例，并在loop() 函数中的死循环里通过 queue.next() 不停的获取监听到的下一个 Message，然后将其通过 dispatchMessage() 分发处理。详细看《Android 基于Handler 剖析消息机制》一文第 4.3 节。

在 Java 端的 MessageQueue 实现核心机制是通过 Native 端的 MessageQueue，该类的对象中维护了一个 native Looper，上面说到的 Java 端的next() 函数就是通过 native 端的 epoll 机制 进行阻塞监听。

之前《Android 基于Handler 剖析消息机制》一文只是对 native Looper 做了简单的介绍，本文将重点分析一下 native Looper 实现机制。

system/core/libutils/include/utils/Looper.hclass Looper : public RefBase {protected:    virtual ~Looper();public:    Looper(bool allowNonCallbacks);    bool getAllowNonCallbacks() const;    int pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData);    inline int pollOnce(int timeoutMillis) {        return pollOnce(timeoutMillis, nullptr, nullptr, nullptr);    }    int pollAll(int timeoutMillis, int* outFd, int* outEvents, void** outData);    inline int pollAll(int timeoutMillis) {        return pollAll(timeoutMillis, nullptr, nullptr, nullptr);    }    void wake();    int addFd(int fd, int ident, int events, Looper_callbackFunc callback, void* data);    int addFd(int fd, int ident, int events, const sp& callback, void* data);    int removeFd(int fd);    void sendMessage(const sp& handler, const Message& message);    void sendMessageDelayed(nsecs_t uptimeDelay, const sp& handler,            const Message& message);    void sendMessageAtTime(nsecs_t uptime, const sp& handler,            const Message& message);    void removeMessages(const sp& handler);    void removeMessages(const sp& handler, int what);    bool isPolling() const;    static sp prepare(int opts);    static void setForThread(const sp& looper);    static sp getForThread();private:    ...    const bool mAllowNonCallbacks; // immutable    android::base::unique_fd mWakeEventFd;  // immutable    Vector mMessageEnvelopes; // guarded by mLock    ...};

简单了列举了下 Looper 类中的成员，后面根据流程再详细说明。

system/core/libutils/Looper.cppLooper::Looper(bool allowNonCallbacks)    : mAllowNonCallbacks(allowNonCallbacks),      mSendingMessage(false),      mPolling(false),      mEpollRebuildRequired(false),      mNextRequestSeq(0),      mResponseIndex(0),      mNextMessageUptime(LLONG_MAX) {    mWakeEventFd.reset(eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC));    LOG_ALWAYS_FATAL_IF(mWakeEventFd.get() < 0, "Could not make wake event fd: %s", strerror(errno));    AutoMutex _l(mLock);    rebuildEpollLocked();}

参数 allowNonCallbacks 指定该 Looper 中是否允许在 addFd() 的时候可以不设定 callback，如果为true，则在addFd() 时可以不用设定callback，如果为 false，则在 addFd() 的时候需要指定 callback，否则会报错，详细可以查看 addFd() 函数。

构造函数中主要做了两件事情：

• 创建一个 wakeEventFd；
• 调用 rebuildEpollLocked() 初始化 epoll；

2.1 rebuildEpollLocked()

system/core/libutils/Looper.cppvoid Looper::rebuildEpollLocked() {    //step1，如果是重构epoll 时的逻辑，需要进行reset    if (mEpollFd >= 0) {#if DEBUG_CALLBACKS        ALOGD("%p ~ rebuildEpollLocked - rebuilding epoll set", this);#endif        mEpollFd.reset();    }    //step2，分配一个新的epoll，并将wakeEventFd添加到监听    mEpollFd.reset(epoll_create1(EPOLL_CLOEXEC));    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.get();    int result = epoll_ctl(mEpollFd.get(), EPOLL_CTL_ADD, mWakeEventFd.get(), &eventItem);    LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake event fd to epoll instance: %s",                        strerror(errno));    //step3，是否有其他的request，如果有，也重新加入到epoll中监听    //一般request 通过addFd 函数添加    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.get(), 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));        }    }}

大致流程如上面注释，主要是三步：

• 如果是重构 epoll 时的逻辑，需要进行reset；
• 分配一个新的 epoll，并将 wakeEventFd添加到监听；
• 是否有其他的 request，如果有，也重新加入到epoll中监听；

system/core/libutils/include/utils/Looper.hclass MessageHandler : public virtual RefBase {protected:    virtual ~MessageHandler();public:        virtual void handleMessage(const Message& message) = 0;};

在 Looper.h 中还定义了 MessageHandler 这样的类，同Java 端的 Handler类，都是用来处理消息的。

当创建好 MessageHandler 对象之后，可以通过 Looper::sendMessage() 函数发送消息到Looper 中，Looper 会在后续的 pollOnce() 中进行监听，最终通过 handleMessage() 函数进行回调处理此次消息。

3.1 sendMessage()

在 Looper.h 中我们看到三个详细的函数：

    void sendMessage(const sp& handler, const Message& message);    void sendMessageDelayed(nsecs_t uptimeDelay, const sp& handler,            const Message& message);    void sendMessageAtTime(nsecs_t uptime, const sp& handler,            const Message& message);

 但其实前面两个函数最终调用的都是 sendMessageAtTime() 函数：

system/core/libutils/Looper.cppvoid Looper::sendMessage(const sp& handler, const Message& message) {    nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);    sendMessageAtTime(now, handler, message);}void Looper::sendMessageDelayed(nsecs_t uptimeDelay, const sp& handler,        const Message& message) {    nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);    sendMessageAtTime(now + uptimeDelay, handler, message);}void Looper::sendMessageAtTime(nsecs_t uptime, const sp& handler,        const Message& message) {#if DEBUG_CALLBACKS    ALOGD("%p ~ sendMessageAtTime - uptime=%" PRId64 ", handler=%p, what=%d",            this, uptime, handler.get(), message.what);#endif    size_t i = 0;    { // acquire lock        AutoMutex _l(mLock);        size_t messageCount = mMessageEnvelopes.size();        while (i < messageCount && uptime >= mMessageEnvelopes.itemAt(i).uptime) {            i += 1;        }        MessageEnvelope messageEnvelope(uptime, handler, message);        mMessageEnvelopes.insertAt(messageEnvelope, i, 1);        // Optimization: If the Looper is currently sending a message, then we can skip        // the call to wake() because the next thing the Looper will do after processing        // messages is to decide when the next wakeup time should be.  In fact, it does        // not even matter whether this code is running on the Looper thread.        if (mSendingMessage) {            return;        }    } // release lock    // Wake the poll loop only when we enqueue a new message at the head.    if (i == 0) {        wake();    }}

这里涉及到了 Looper 中的另外一个成员变量：mMessageEnvelopes，这是一个 Vector 类型变量，用以存放通过 sendMessage() 发送到 Looper 中的消息。

如代码所示，会将 message、message handler、uptime 都存放在一个信封对象中，然后将该信封添加到 mMessageEnvelopes 中。

这里还涉及另外一个成员变量：mSendingMessage，用以标记当前是否正在 handleMessage() 处理消息。当该函数执行的时候，mSendingMessage 被置 true，标记正在处理，在处理函数完成之后会将其再次置 false。

system/core/libutils/include/utils/Looper.hclass LooperCallback : public virtual RefBase {protected:    virtual ~LooperCallback();public:        virtual int handleEvent(int fd, int events, void* data) = 0;};

该类用以处理通过 addFd() 添加监听的 fd。在 addFd() 函数中会同步指定 callback，就是这里的 LooperCallback 对象。

4.1 addFd()

在 Looper.h 中可以看到该函数的声明：

    int addFd(int fd, int ident, int events, Looper_callbackFunc callback, void* data);    int addFd(int fd, int ident, int events, const sp& callback, void* data);

system/core/libutils/Looper.cppint Looper::addFd(int fd, int ident, int events, Looper_callbackFunc callback, void* data) {    return addFd(fd, ident, events, callback ? new SimpleLooperCallback(callback) : nullptr, data);}int Looper::addFd(int fd, int ident, int events, const sp& callback, void* data) {    if (!callback.get()) {        if (! mAllowNonCallbacks) {            ALOGE("Invalid attempt to set NULL callback but not allowed for this looper.");            return -1;        }        if (ident < 0) {            ALOGE("Invalid attempt to set NULL callback with ident < 0.");            return -1;        }    } else {        ident = POLL_CALLBACK;    }    { // acquire lock        AutoMutex _l(mLock);        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);        if (requestIndex < 0) {            int epollResult = epoll_ctl(mEpollFd.get(), EPOLL_CTL_ADD, fd, &eventItem);            if (epollResult < 0) {                ALOGE("Error adding epoll events for fd %d: %s", fd, strerror(errno));                return -1;            }            mRequests.add(fd, request);        } else {            int epollResult = epoll_ctl(mEpollFd.get(), EPOLL_CTL_MOD, fd, &eventItem);            if (epollResult < 0) {                if (errno == ENOENT) {                    epollResult = epoll_ctl(mEpollFd.get(), EPOLL_CTL_ADD, fd, &eventItem);                    if (epollResult < 0) {                        ALOGE("Error modifying or adding epoll events for fd %d: %s",    fd, strerror(errno));                        return -1;                    }                    scheduleEpollRebuildLocked();                } else {                    ALOGE("Error modifying epoll events for fd %d: %s", fd, strerror(errno));                    return -1;                }            }            mRequests.replaceValueAt(requestIndex, request);        }    } // release lock    return 1;}

这里涉及到 Looper 中的另外一个成员变量：mRequests，这是一个KeyedVector 类型的变量，用以存放通过 addFd() 添加的监听请求。

如代码所示，首先确认 mRequests 中是否已经存放该 fd 的监听，如果没有，则通过 epoll_ctl() 将对该 fd 的监听添加到 epoll 中，并将此次的请求添加到 mRequests 中；如果已经存在对该 fd 的监听，则对 epoll 进行更改，并将 mRequests 中的request 进行替换。

当 pollOnce() 中收到 epoll 的event 为该 mRequests 中的 fd 消息时，会将响应的 event 暂存在 Looper 中的另一个成员变量 mResponses 中，接着 pollOnce() 中会确认这些 fd 消息是否需要 callback 处理，如果callback 处理成功则将此次的响应消息从 mResponses 中移除。详细请查看下面第 6 节pollOnce() 函数。

另外，需要注意这里的 ident (identifier 简称)参数，可以在传入的时候指定为 POLL_CALLBACK 等枚举值（这些值都为负数），也可以设定为一个 >= 0 的其他值。但是，如果该 ident 值为 >=0 时，pollOnce() 调用时会将该次响应的数据取出并return，详细看第 6 节 pollOnce() 函数。

system/core/libutils/Looper.cppvoid Looper::wake() {#if DEBUG_POLL_AND_WAKE    ALOGD("%p ~ wake", this);#endif    uint64_t inc = 1;    ssize_t nWrite = TEMP_FAILURE_RETRY(write(mWakeEventFd.get(), &inc, sizeof(uint64_t)));    if (nWrite != sizeof(uint64_t)) {        if (errno != EAGAIN) {            LOG_ALWAYS_FATAL("Could not write wake signal to fd %d (returned %zd): %s", mWakeEventFd.get(), nWrite, strerror(errno));        }    }}

通过往 mWakeEventFd 中写个数据来达到唤醒的目的。

先来看下在Looper.h 中的声明：

    int pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData);    inline int pollOnce(int timeoutMillis) {        return pollOnce(timeoutMillis, nullptr, nullptr, nullptr);    }

参数 timeoutMillis 单位为 毫秒；

注意，pollOnce() 可以只传一个 timeout 的参数，此时其他参数默认为 nullptr。

调用该函数用以等待一个 event 的产生。

• 如果timeout 为0，则不用阻塞立即返回；
• 如果timeout 为负数，则无限等待一直等到一个 event 出现；
• 如果在 timeout 到期之前，或者callback被调用之前，或者没有fd 准备好之前，epoll 被wake() 函数唤醒时，返回 POLL_WAKE，这也是默认返回类型；
• 如果是 callback 被调用处理时，返回POLL_CALLBACK；
• 如果是 timeout 到期时，返回 POLL_TIMEOUT；
• 如果出现错误时，返回 POLL_ERROR；
• 该函数直到完成所有的 fd 所有对应的合适的 callback 调用之后，才会 return；

详细的逻辑可以查看源码：

system/core/libutils/Looper.cppint Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {    int result = 0;    for (;;) {        //确定是否有fd 响应，如果 ident 为>=0的值，则直接返回；        // 如果ident 为负数，则进行下一次的 pollInner()等待、处理；        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 != nullptr) *outFd = fd;                if (outEvents != nullptr) *outEvents = events;                if (outData != nullptr) *outData = data;                return ident;            }        }        //pollInner() 处理结果确定，一般不会为0        if (result != 0) {            if (outFd != nullptr) *outFd = 0;            if (outEvents != nullptr) *outEvents = 0;            if (outData != nullptr) *outData = nullptr;            return result;        }        //pollOnce 函数的核心处理部分，epoll机制监听、处理的地方        result = pollInner(timeoutMillis);    }}

在调用 pollInner() 函数之前，会通过 while() 循环将所有 fd 的响应进行确认，如果出现了 fd 的消息没有经过callback 处理，那么该 fd 的响应还会留在 mResponses 中。设计的初衷应该是希望 fd 的消息可以通过指定的 callback（第4节中的LooperCallback 对象） 处理，如果不需要 callback 处理，则会将 ident 参数值设为 >=0 的值，这样在此处的 while 循环就可以从 pollOnce() 中 return。

6.1 pollInner()

system/core/libutils/Looper.cppint Looper::pollInner(int timeoutMillis) {    //step1，确定timeout    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;        }    }    //step2，进入真正poll处理，先清空 mResponses之前的残留    int result = POLL_WAKE;    mResponses.clear();    mResponseIndex = 0;    // We are about to idle.    mPolling = true;    //step3，等待epoll监听到消息    struct epoll_event eventItems[EPOLL_MAX_EVENTS];    int eventCount = epoll_wait(mEpollFd.get(), eventItems, EPOLL_MAX_EVENTS, timeoutMillis);    // No longer idling.    mPolling = false;    // Acquire lock.    mLock.lock();    //step4，当fd的修改、删除出现问题时，需要重构epoll    if (mEpollRebuildRequired) {        mEpollRebuildRequired = false;        rebuildEpollLocked();        goto Done;    }    //step5, 如果event count 小于0，则表示epoll出错，答应错误并结束event处理    if (eventCount < 0) {        if (errno == EINTR) {            goto Done;        }        ALOGW("Poll failed with an unexpected error: %s", strerror(errno));        result = POLL_ERROR;        goto Done;    }    //step6，如果event count 为0，则表示timeout 到期，进入timeout处理    if (eventCount == 0) {        result = POLL_TIMEOUT;        goto Done;    }    //step7，收到了event，确定是wake() 触发，还是fd 消息    for (int i = 0; i < eventCount; i++) {        int fd = eventItems[i].data.fd;        uint32_t epollEvents = eventItems[i].events;        //是被调用wake() 唤醒的        if (fd == mWakeEventFd.get()) {            if (epollEvents & EPOLLIN) {                awoken();            } else {                ALOGW("Ignoring unexpected epoll events 0x%x on wake event fd.", epollEvents);            }        } else {            ssize_t requestIndex = mRequests.indexOfKey(fd);            if (requestIndex >= 0) {//是fd消息唤醒的，将event暂存mResponses 中                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;                pushResponse(events, mRequests.valueAt(requestIndex));            } else {                ALOGW("Ignoring unexpected epoll events 0x%x on fd %d that is "                        "no longer registered.", epollEvents, fd);            }        }    }Done: ;    //step8，处理messages，timeout 触发    mNextMessageUptime = LLONG_MAX;    while (mMessageEnvelopes.size() != 0) {        nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);        const MessageEnvelope& messageEnvelope = mMessageEnvelopes.itemAt(0);        if (messageEnvelope.uptime <= now) {            { // obtain handler                sp handler = messageEnvelope.handler;                Message message = messageEnvelope.message;                mMessageEnvelopes.removeAt(0);                mSendingMessage = true;                mLock.unlock();                //处理message                handler->handleMessage(message);            } // release handler            mLock.lock();            mSendingMessage = false;            result = POLL_CALLBACK;        } else {            // The last message left at the head of the queue determines the next wakeup time.            mNextMessageUptime = messageEnvelope.uptime;            break;        }    }    // Release lock.    mLock.unlock();    //step9，fd 消息响应，进行fd 指定的callback处理    for (size_t i = 0; i < mResponses.size(); i++) {        Response& response = mResponses.editItemAt(i);        //如果fd 指定了callback，则调用handleEvent() 处理        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);            //handleEvent 处理成功，则需要返回0，表示处理完成，退出Looper            //当然，也可以返回非0，表示继续等待callback处理，不退出Looper            if (callbackResult == 0) {                removeFd(fd, response.request.seq);            }            // Clear the callback reference in the response structure promptly because we            // will not clear the response vector itself until the next poll.            response.request.callback.clear();            result = POLL_CALLBACK;        }    }    return result;}

流程比较长，详细的分析见代码中的注释，重点情况在addFd() 分析时或者pollOnce() 分析时已经说明，请参考上文。

7.1 removeFd()

与addFd() 相反，将 fd 监听从 mRequests 中移除，并从 epoll 监听中移除。

7.2 isPolling()

确定当前Looper 是否处于 epoll_wait() 阻塞，如果epoll_wait() 没有返回，则说明 Looper 处于 polling 状态。

至此，native Looper的原理已经基本分析完成。核心是通过 epoll 机制进行监听，针对：

• message 的timeout，通过 sendMessage() 加入到 mMessageEnvelopes 中；
• wake fd 的灵活唤醒，通过创建 wake event fd 监听，wake() 进行唤醒；
• 其他 fd 的poll event 唤醒，通过 addFd() 加入到 mRequests 中；

其他关联博文： 

Android 基于Handler 剖析消息机制 

Android 中Handler 详解

Android AsyncTask 详解

Android HandlerThread 详解

来源地址：https://blog.csdn.net/jingerppp/article/details/131377033