安卓异步消息处理机制ALooper

最新推荐文章于 2023-06-25 17:17:47 发布

妳好陌生人

最新推荐文章于 2023-06-25 17:17:47 发布

阅读量749

点赞数

分类专栏： ALooper AHandler 文章标签： ALooper loop post

本文链接：https://blog.csdn.net/u011294619/article/details/60132677

版权

ALooper 同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

AHandler

2 篇文章 0 订阅

订阅专栏

1.下面贴出安卓N版本ALooper.h的原文

#ifndef A_LOOPER_H_

#define A_LOOPER_H_

#include <media/stagefright/foundation/ABase.h>
#include <media/stagefright/foundation/AString.h>
#include <utils/Errors.h>
#include <utils/KeyedVector.h>
#include <utils/List.h>
#include <utils/RefBase.h>
#include <utils/threads.h>

namespace android {

struct AHandler;
struct AMessage;
struct AReplyToken;

struct ALooper : public RefBase {
    typedef int32_t event_id;
    typedef int32_t handler_id;

    ALooper();

    // Takes effect in a subsequent call to start().
    void setName(const char *name);

    handler_id registerHandler(const sp<AHandler> &handler);
    void unregisterHandler(handler_id handlerID);

    status_t start(
            bool runOnCallingThread = false,
            bool canCallJava = false,
            int32_t priority = PRIORITY_DEFAULT
            );

    status_t stop();

    static int64_t GetNowUs();

    const char *getName() const {
        return mName.c_str();
    }

protected:
    virtual ~ALooper();

private:
    friend struct AMessage;       // post()

    struct Event {
        int64_t mWhenUs;
        sp<AMessage> mMessage;
    };

    Mutex mLock;
    Condition mQueueChangedCondition;

    AString mName;

    List<Event> mEventQueue;

    struct LooperThread;
    sp<LooperThread> mThread;
    bool mRunningLocally;

    // use a separate lock for reply handling, as it is always on another thread
    // use a central lock, however, to avoid creating a mutex for each reply
    Mutex mRepliesLock;
    Condition mRepliesCondition;

    // START --- methods used only by AMessage

    // posts a message on this looper with the given timeout
    void post(const sp<AMessage> &msg, int64_t delayUs);

    // creates a reply token to be used with this looper
    sp<AReplyToken> createReplyToken();
    // waits for a response for the reply token.  If status is OK, the response
    // is stored into the supplied variable.  Otherwise, it is unchanged.
    status_t awaitResponse(const sp<AReplyToken> &replyToken, sp<AMessage> *response);
    // posts a reply for a reply token.  If the reply could be successfully posted,
    // it returns OK. Otherwise, it returns an error value.
    status_t postReply(const sp<AReplyToken> &replyToken, const sp<AMessage> &msg);

    // END --- methods used only by AMessage

    bool loop();

    DISALLOW_EVIL_CONSTRUCTORS(ALooper);
};

} // namespace android

#endif  // A_LOOPER_H_

1.1条件编译

#ifndef A_LOOPER_H_

#define A_LOOPER_H_

...
...
...
#endif  // A_LOOPER_H_

　　条件编译宏，防止重复编译。

1.2包含的头文件

#include <media/stagefright/foundation/ABase.h>
#include <media/stagefright/foundation/AString.h>
#include <utils/Errors.h>
#include <utils/KeyedVector.h>
#include <utils/List.h>
#include <utils/RefBase.h>
#include <utils/threads.h>

1.3名字空间

namespace android {

...
...
...

}

2.重要结构体struct Event

    struct Event {
        int64_t mWhenUs;
        sp<AMessage> mMessage;
    };

    List<Event> mEventQueue;

　　结构体struct Event有两个域，一个域是一个64bits的整数，是消息发送过来时给消息打的时间戳。

　　打的时间戳计算方法为：mWhenU＝GetNowUs() + delayUs　（delayUs > 0），即当用户设置的延时delayUs大于０的时候，给消息打的时间戳为系统时间（GetNowUs()）加上用户设置的延时（delayUs）。

　　如果用户设置的延时delayUs小于等于０的时候，则直接采用系统时间（GetNowUs()）给该消息打时间戳：whenUs = GetNowUs()

　　List< Event > mEventQueue,将所有发送来的消息打上时间戳后封装成事件都放到mEventQueue链表里，注意事件在链表里存放的顺序是按打的时间戳递增顺序来存放的。由于会频繁的向事件链表里插入事件，采用链式存储的表List是最合适的，因为插入和删除动作能在Ｏ(1)事件内完成。

3.ALooper::post函数的实现

　　下面贴出安卓N版本ALooper::post函数的实现

void ALooper::post(const sp<AMessage> &msg, int64_t delayUs) {
    Mutex::Autolock autoLock(mLock);

    int64_t whenUs;
    if (delayUs > 0) {
        whenUs = GetNowUs() + delayUs;
    } else {
        whenUs = GetNowUs();
    }

    List<Event>::iterator it = mEventQueue.begin();
    while (it != mEventQueue.end() && (*it).mWhenUs <= whenUs) {
        ++it;
    }

    Event event;
    event.mWhenUs = whenUs;
    event.mMessage = msg;

    if (it == mEventQueue.begin()) {
        mQueueChangedCondition.signal();
    }

    mEventQueue.insert(it, event);
}

　　好了，前面介绍了ALooper的消息存储机制，现在来看下ALopper是如何设计外部接口来向事件链表里添加消息对应的事件的吧。

3.1给该消息计算时间戳

    int64_t whenUs;
    if (delayUs > 0) {
        whenUs = GetNowUs() + delayUs;
    } else {
        whenUs = GetNowUs();
    }

　　这个在前面已经讲到了，即根据delayUs的值来选择不同的计算时间戳的方法。

3.2计算该事件该插入的位置

    List<Event>::iterator it = mEventQueue.begin();
    while (it != mEventQueue.end() && (*it).mWhenUs <= whenUs) {
        ++it;
    }

　　这个很显然咯，就是从链表第一个位置，不停地迭代，直到找到第一个时间戳大于该事件的时间戳的位置it.然后将该事件插入到it的前面。这个很简单咯，但是真的很基础，数据结构链表的知识，就这样简单的迭代计算，大量地在安卓系统源码里用到。

3.3封装成事件

    Event event;
    event.mWhenUs = whenUs;
    event.mMessage = msg;

　　就是分别用计算得到的时间戳，和消息的引用来填充Event结构体的两个域。来完成事件的封装。

3.4事件添加到链表里

mEventQueue.insert(it, event);

　　就是将该事件插入到it前面。it是之前计算得到的位置。

4.ALooper::loop函数的实现

　　下面贴出安卓N版本ALooper::loop函数实现源码：

bool ALooper::loop() {
    Event event;

    {
        Mutex::Autolock autoLock(mLock);
        if (mThread == NULL && !mRunningLocally) {
            return false;
        }
        if (mEventQueue.empty()) {
            mQueueChangedCondition.wait(mLock);
            return true;
        }
        int64_t whenUs = (*mEventQueue.begin()).mWhenUs;
        int64_t nowUs = GetNowUs();

        if (whenUs > nowUs) {
            int64_t delayUs = whenUs - nowUs;
            mQueueChangedCondition.waitRelative(mLock, delayUs * 1000ll);

            return true;
        }

        event = *mEventQueue.begin();
        mEventQueue.erase(mEventQueue.begin());
    }

    event.mMessage->deliver();

    // NOTE: It's important to note that at this point our "ALooper" object
    // may no longer exist (its final reference may have gone away while
    // delivering the message). We have made sure, however, that loop()
    // won't be called again.

    return true;
}

　　这个loop函数将被指定成函数入口，通过安卓系统实现的线程机制该入口函数将会不断地被调用。通俗的来说就是这个loop函数会不断低被执行，可以这样理解do { loop();} while(1);,但是真实的实现机制是比较复杂滴，后续的文章有机会的话会像大家介绍。
　　好了，这样就是建立了一个循环，在该循环里不断地将链表里第一个事件，也就是时间戳最小的事件，取出该事件，然后将该事件的消息派发出去。这样的设计很自然，因为时间戳越小说明该消息到达得越早，显然需要被优先处理。
　

4.1循环派发消息

        int64_t whenUs = (*mEventQueue.begin()).mWhenUs;
        int64_t nowUs = GetNowUs();

        if (whenUs > nowUs) {
            int64_t delayUs = whenUs - nowUs;
            mQueueChangedCondition.waitRelative(mLock, delayUs * 1000ll);

            return true;
        }

        event = *mEventQueue.begin();
        mEventQueue.erase(mEventQueue.begin());

　　首先得到链表第一个事件的时间戳，然后得到当前系统的时间戳，如果事件的事件戳小于或者等于系统时间，说明该事件需要被派发出去不需要在链表里继续等待了。则跳过if (whenUs > nowUs)分支。
　　
　　取出链表第一个事件，然后调用该事件消息的deliver()函数将该消息派发出去：　

   event.mMessage->deliver();

5.ALooper::registerHandler

　　下面贴出安卓N版本ALooper::registerHandler函数实现的源码：

ALooper::handler_id ALooper::registerHandler(const sp<AHandler> &handler) {
    return gLooperRoster.registerHandler(this, handler);
}

　　ALooper::registerHandler函数是通过调用全局对象gLooperRoster的registerHandler函数来实现的。当调用全局对象gLooperRoster的registerHandler函数，是传递的参数是，自身即消息链表的维护者（ALooper）引用和消息处理者（AHandler）。这样就将ALooper和AHandler绑定成一对儿来通过全局对象gLooperRoster的registerHandler函数来完成注册了。