五分钟用C++11实现Android系统的Handler机制

背景

  线程作为系统的基础资源,相信大多数读者都有使用到。一般情况下我们会直接开一个线程做一些耗时操作,处理完之后让线程自动结束,资源被系统回收。这种简单粗暴的方法不少读者、甚至一些大厂的APP都在用。以Java语言为例,我们可以直接new一个Thread对象,然后覆盖run方法,最后调一下start方法便可以成功运行一个线程。如果我们每次异步做一些耗时处理都单独开启一个线程,比如异步加载网络图片这种高并发操作,每张图片都开一个线程的话,必然会造成线程资源的浪费,而且也没有很好的方法去处理跨线程通讯的问题。由于语言层面的低成本导致系统的线程资源被滥用,已经成为了一个很普遍的现象。
  Android系统的Handler是一种很好的解决以上问题的机制,如果能够在C/C++实现这样一套机制,将会极大的降低C/C++多线程的使用成本。通过本文你将了解到Android系统的Handler的实现原理,以及如何使用C/C++来实现这样一套机制。本文不打算过多的介绍Android系统中的源码实现,而是直接使用C++11来实现。

new Thread(){
    @Override
    public void run() {
        //Do somethings
    }
}.start();

Handler

  Handler机制通过开启一个子线程,并进入死循环,不停消费其它线程发送过来的消息,从而达到跨线程通讯的目的。Handler主要用于跨线程通讯,但同时也能在一定程度上复用线程,是一种比较理想的线程使用方式。Android系统Handler主要包含以下三部分:

  • Handler
  • Looper
  • Message & MessageQueue

  Handler顾名思义就是消息的处理类,同时也是消息发送的代理入口,通过调用Handler的相关接口发送一条消息,最终会被转发到Looper,由Looper把Message加入到队列的尾部。Looper是消息循环驱动的动力所在,我们规定同一个线程只能拥有一个Looper,当Looper准备好之后会让线程进入死循环,如果内部的Message队列不为空时,则会不停的从消息队列头部取出一条Message进行消费,直到队列为空,Looper阻塞线程进入等待状态。Message内部会记录着发送消息的Handler,当被消费时就可以找到对应的Handler进行消息处理,最终形成闭环。

Handler机制

实现

  下面尝试使用C++11来实现Android系统Handler机制,该实现主要由AlHandlerThreadAlHandlerAlLooperManagerAlLooperAlMessageQueueAlMessage六个类组成。我们规定一个线程只能拥有一个AlLooper,因此需要一个AlLooperManager负责对所有线程的AlLooper对象进行管理,如果当前线程已经拥有了AlLooper对象,则直接使用当前线程的对象,保证AlLooper唯一。而AlMessageQueue则是一个支持线程阻塞和唤醒的消息队列。AlHandlerThread则是一个封装了std::threadAlLooper的简单线程实现,仅仅是为了方便使用AlLooper,与Android系统中的HandlerThread实现是一致的。

UML

AlHandler

  AlHandler提供两个构造函数,第一个只有Callback参数,该构造函数会默认获取当前线程的AlLooper,如果当前没有AlLooper,则会抛出异常。第二个构造函数支持传入一个AlLooper,该AlLooper对象将会从AlHandlerThread获取。sendMessage函数负责把AlMessage转发到AlLooper,值得注意的是,在发送到AlLooper之前会先给AlMessage的成员变量target赋值,也就是当前AlHandler对象的指针。dispatchMessage函数用于在AlLooper中消费消息。

class AlHandler {
public:
    typedef function<void(AlMessage *msg)> Callback;
public:
    AlHandler(Callback callback);

    AlHandler(AlLooper *looper, Callback callback);

    void sendMessage(AlMessage *msg)  {
        _enqueueMessage(msg);
    }

    void dispatchMessage(AlMessage *msg) {
        if (callback) {
            callback(msg);
        }
    }

private:
    void _enqueueMessage(AlMessage *msg) {
        if (this->looper) {
            msg->target = this;
            this->looper->sendMessage(msg);
        }
    }

private:
    AlLooper *looper = nullptr;
    Callback callback = nullptr;
};

AlLooperManager

  AlLooperManager只有一个功能,那就是管理所有创建的AlLooper对象,所以它是一个单例,代码虽然简单,但却很重要。由于操作系统会为每一个线程分配一个唯一的tid(Thread ID,Linux下可以使用pthread_self获取到),所以我们可以通过tid的唯一性来管理所有线程创建的AlLooper对象。该类的createget函数分别用于创建新的AlLooper对象,以及获取缓存的对象。创建一个对象时首先需要检查缓存中是否存在该线程对应的AlLooper,如果已经存在则应该避免重复创建,直接返回空指针即可。而get函数用于从缓存中获取一个对象,如果缓存中没有则返回空指针。remove用于销毁一个AlLooper,一般会在线程销毁时使用。这几个函数都需要保证线程安全。

private:
    AlLooperManager() : Object() {}

    AlLooperManager(AlLooperManager &e) : Object() {}

    ~AlLooperManager() {}

    /**
     * 为当前线程创建Looper
     * @return 当前线程的Looper
     */
    AlLooper *create(long tid) {
        std::lock_guard<std::mutex> guard(mtx);
        auto it = looperMap.find(tid);
        if (looperMap.end() == it) {
            auto *looper = new AlLooper();
            looperMap[tid] = looper;
            return looper;
        }
        return nullptr;
    }

    /**
     * 获取当前线程的Looper
     * @return 当前线程的Looper
     */
    AlLooper *get(long tid) {
        std::lock_guard<std::mutex> guard(mtx);
        auto it = looperMap.find(tid);
        if (looperMap.end() == it) {
            return nullptr;
        }
        return it->second;
    }

    /**
     * 销毁当前线程的Looper
     */
    void remove(long tid) {
        std::lock_guard<std::mutex> guard(mtx);
        auto it = looperMap.find(tid);
        if (looperMap.end() != it) {
            looperMap.erase(it);
            auto *looper = it->second;
            delete looper;
        }
    }

private:
    static AlLooperManager *instance;
    std::map<long, AlLooper *> looperMap;
    std::mutex mtx;
};

AlLooper

  AlLooper主要有preparemyLooperloop三个静态函数。prepare用于为当前线程准备一个AlLooper,因为我们规定同一个线程只能拥有一个AlLooper对象,如果尝试在一个线程重复调用该函数函数将引发异常。myLooper用于获取当前线程的AlLooper,如果在该函数调用之前没有调用过prepare将会获得一个空指针。loopAlLooper的核心函数,调用该函数后线程将进入死循环,AlLooper会依次从消息队列头部取出AlMessage进行消费。前面提到AlMessage有一个名为target的成员变量,这个变量是一个AlHandler对象,所以这里直接调用AlHandler::dispatchMessage函数把消息回传,由AlHandler进行处理。sendMessage函数则用于在消息队列尾部插入一条消息。

class AlLooper : public Object {
public:
    /**
     * 为线程准备一个Looper,如果线程已经存在Looper,则报错
     */
    static void prepare() {
        AlLooper *looper = AlLooperManager::getInstance()->create(Thread::currentThreadId());
        assert(nullptr != looper);
    }

    /**
     * 获取当前线程的Looper
     * @return 前线程的Looper
     */
    static AlLooper *myLooper() {
        AlLooper *looper = AlLooperManager::getInstance()->get(Thread::currentThreadId());
        assert(nullptr != looper);
        return looper;
    }

    static void  exit();

    /**
     * 循环消费消息
     */
    static void loop()  {
        myLooper()->_loop();
    }

    void _loop() {
        for (;;) {
            AlMessage *msg = queue.take();
            if (msg) {
                if (msg->target) {
                    msg->target->dispatchMessage(msg);
                }
                delete msg;
            }
            queue.pop();
        }
    }

    void sendMessage(AlMessage *msg) {
        queue.offer(msg);
    }

private:
    AlLooper();

    AlLooper(AlLooper &e) : Object() {}

    ~AlLooper();

private:
    AlMessageQueue queue;
};

AlMessageQueue和AlMessage

  AlMessage比较简单,主要包含几个public的成员变量,用于区分消息类型以及附带一些信息。AlMessageQueue则是一个阻塞队列,当尝试从一个空队列获取AlMessage时将会造成线程阻塞,如果其它线程向空队列新增一个AlMessage对象将会唤醒阻塞的线程。这是驱动消息循环消费的重要一环。

class AlMessage {
public:
    int32_t what = 0;
    int32_t arg1 = 0;
    int64_t arg2 = 0;
    Object *obj = nullptr;
}

class AlMessageQueue : public Object {
public:
    AlMessageQueue()  {
        pthread_mutex_init(&mutex, nullptr);
        pthread_cond_init(&cond, nullptr);
    }

    virtual ~AlMessageQueue() {
        pthread_mutex_lock(&mutex);
        invalid = true;
        pthread_mutex_unlock(&mutex);
        clear();
        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&cond);
    }

    void offer(AlMessage *msg) {
        pthread_mutex_lock(&mutex);
        if (invalid) {
            pthread_mutex_unlock(&mutex);
            return;
        }
        queue.push_back(msg);

        pthread_cond_broadcast(&cond);
        pthread_mutex_unlock(&mutex);
    }

    AlMessage *take() {
        pthread_mutex_lock(&mutex);
        if (invalid) {
            pthread_mutex_unlock(&mutex);
            return nullptr;
        }
        if (size() <= 0) {
            if (0 != pthread_cond_wait(&cond, &mutex)) {
                pthread_mutex_unlock(&mutex);
                return nullptr;
            }
        }
        if (queue.empty()) {
            pthread_mutex_unlock(&mutex);
            return nullptr;
        }
        AlMessage *e = queue.front();
        queue.pop_front();

        pthread_mutex_unlock(&mutex);
        return e;
    }

    int size();

    void clear();

private:
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    std::list<AlMessage *> queue;
    bool invalid = false;
};

AlHandlerThread

  AlLooper准备好后就可以在线程中使用了,这里我们把线程和AlLooper封装到一起方便使用。AlHandlerThread会在内部开启一个线程,该线程会调用run函数,在线程开始运行后依次调用AlLooperprepareloop函数即可进入消息消费流程,AlLooper::exit()用于在线程结束前销毁AlLooper对象。

class AlHandlerThread {
public:
    AlLooper *getLooper() {
        return mLooper;
    }

private:
    void run() {
        AlLooper::prepare();
        mLooper = AlLooper::myLooper();
        AlLooper::loop();
        AlLooper::exit();
    }

private:
    std::thread mThread = thread(&AlHandlerThread::run, this);
    AlLooper *mLooper = nullptr;
};

  最后我们创建一个AlHandler对象,并传入一个从AlHandlerThread获取的AlLooper对象和一个处理回调函数Callback,便可以让Handler机制运行起来。由于AlLooper可以是任意一个线程的对象,所以便实现了跨线程的通讯。如果我们把AlMessage封装成一个"Task",当我们要处理一个耗时任务时,把任务封装成一个"Task"发送到Handler进行处理,通过该方法可以轻易实现线程的复用,而不需要重复申请销毁线程。

mThread = AlHandlerThread::create(name);
mHandler = new AlHandler(mThread->getLooper(), [this](AlMessage *msg) {
    /// Do something.
});

结语

  以上便是Android系统Handler机制的介绍,以及使用C++11的实现。上面展示的是部分核心代码,省略了很多,实际操作还需要处理很多问题,比如线程安全、线程的退出、AlLooper的销毁等。文章源码出自hwvc,感兴趣的读者可以阅读完整的AlHandlerThread源码实现。


Homepage

推荐阅读更多精彩内容