使用C++11实现Android系统的Handler机制

封面出自：板栗懒得很背景

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

1. new Thread(){
2.  
3. @Override
4.  
5. public void run() {
6.  
7. //Do somethings
8.  
9. }
10.  
11. }.start()

Handler

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

• Handler
• Looper
• Message & MessageQueue

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

实现

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

AlHandler

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

1. class AlHandler {
2. public:
3. typedef function<void(AlMessage *msg)> Callback;
4. public:
5. AlHandler(Callback callback);
6. AlHandler(AlLooper *looper, Callback callback);
7. void sendMessage(AlMessage *msg) {
8. _enqueueMessage(msg);
9. }
10. void dispatchMessage(AlMessage *msg) {
11. if (callback) {
12. callback(msg);
13. }
14. }
15. private:
16. void _enqueueMessage(AlMessage *msg) {
17. if (this->looper) {
18. msg->target = this;
19. this->looper->sendMessage(msg);
20. }
21. }
22. private:
23. AlLooper *looper = nullptr;
24. Callback callback = nullptr;
25. };

AlLooperManager

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

1. private:
2. AlLooperManager() : Object() {}
3. AlLooperManager(AlLooperManager &e) : Object() {}
4. ~AlLooperManager() {}
5. /**
6. * 为当前线程创建Looper
7. * @return 当前线程的Looper
8. */
9. AlLooper *create(long tid) {
10. std::lock_guard<std::mutex> guard(mtx);
11. auto it = looperMap.find(tid);
12. if (looperMap.end() == it) {
13. auto *looper = new AlLooper();
14. looperMap[tid] = looper;
15. return looper;
16. }
17. return nullptr;
18. }
19. /**
20. * 获取当前线程的Looper
21. * @return 当前线程的Looper
22. */
23. AlLooper *get(long tid) {
24. std::lock_guard<std::mutex> guard(mtx);
25. auto it = looperMap.find(tid);
26. if (looperMap.end() == it) {
27. return nullptr;
28. }
29. return it->second;
30. }
31. /**
32. * 销毁当前线程的Looper
33. */
34. void remove(long tid) {
35. std::lock_guard<std::mutex> guard(mtx);
36. auto it = looperMap.find(tid);
37. if (looperMap.end() != it) {
38. looperMap.erase(it);
39. auto *looper = it->second;
40. delete looper;
41. }
42. }
43. private:
44. static AlLooperManager *instance;
45. std::map<long, AlLooper *> looperMap;
46. std::mutex mtx;
47. };

AlLooper

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

1. class AlLooper : public Object {
2. public:
3. /**
4. * 为线程准备一个Looper，如果线程已经存在Looper，则报错
5. */
6. static void prepare() {
7. AlLooper *looper = AlLooperManager::getInstance()->create(Thread::currentThreadId());
8. assert(nullptr != looper);
9. }
10. /**
11. * 获取当前线程的Looper
12. * @return 前线程的Looper
13. */
14. static AlLooper *myLooper() {
15. AlLooper *looper = AlLooperManager::getInstance()->get(Thread::currentThreadId());
16. assert(nullptr != looper);
17. return looper;
18. }
19. static void exit();
20. /**
21. * 循环消费消息
22. */
23. static void loop() {
24. myLooper()->_loop();
25. }
26. void _loop() {
27. for (;;) {
28. AlMessage *msg = queue.take();
29. if (msg) {
30. if (msg->target) {
31. msg->target->dispatchMessage(msg);
32. }
33. delete msg;
34. }
35. queue.pop();
36. }
37. }
38. void sendMessage(AlMessage *msg) {
39. queue.offer(msg);
40. }
41. private:
42. AlLooper();
43. AlLooper(AlLooper &e) : Object() {}
44. ~AlLooper();
45. private:
46. AlMessageQueue queue;
47. };

AlMessageQueue和AlMessage

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

1. class AlMessage {
2. public:
3. int32_t what = 0;
4. int32_t arg1 = 0;
5. int64_t arg2 = 0;
6. Object *obj = nullptr;
7. }
8. class AlMessageQueue : public Object {
9. public:
10. AlMessageQueue() {
11. pthread_mutex_init(&mutex, nullptr);
12. pthread_cond_init(&cond, nullptr);
13. }
14. virtual ~AlMessageQueue() {
15. pthread_mutex_lock(&mutex);
16. invalid = true;
17. pthread_mutex_unlock(&mutex);
18. clear();
19. pthread_mutex_destroy(&mutex);
20. pthread_cond_destroy(&cond);
21. }
22. void offer(AlMessage *msg) {
23. pthread_mutex_lock(&mutex);
24. if (invalid) {
25. pthread_mutex_unlock(&mutex);
26. return;
27. }
28. queue.push_back(msg);
29. pthread_cond_broadcast(&cond);
30. pthread_mutex_unlock(&mutex);
31. }
32. AlMessage *take() {
33. pthread_mutex_lock(&mutex);
34. if (invalid) {
35. pthread_mutex_unlock(&mutex);
36. return nullptr;
37. }
38. if (size() <= 0) {
39. if (0 != pthread_cond_wait(&cond, &mutex)) {
40. pthread_mutex_unlock(&mutex);
41. return nullptr;
42. }
43. }
44. if (queue.empty()) {
45. pthread_mutex_unlock(&mutex);
46. return nullptr;
47. }
48. AlMessage *e = queue.front();
49. queue.pop_front();
50. pthread_mutex_unlock(&mutex);
51. return e;
52. }
53. int size();
54. void clear();
55. private:
56. pthread_mutex_t mutex;
57. pthread_cond_t cond;
58. std::list<AlMessage *> queue;
59. bool invalid = false;
60. };

AlHandlerThread

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

1. class AlHandlerThread {
2. public:
3. AlLooper *getLooper() {
4. return mLooper;
5. }
6. private:
7. void run() {
8. AlLooper::prepare();
9. mLooper = AlLooper::myLooper();
10. AlLooper::loop();
11. AlLooper::exit();
12. }
13. private:
14. std::thread mThread = thread(&AlHandlerThread::run, this);
15. AlLooper *mLooper = nullptr;
16. };

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

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

结语

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

hwvc项目：

https://github.com/imalimin/hwvc/tree/develop

AlHandlerThread源码：

https://github.com/imalimin/hwvc/blob/develop/src/common/thread/AlHandlerThread.cpp

到此这篇关于使用C++11实现Android系统的Handler机制的文章就介绍到这了,更多相关C++11 Handler机制内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://mp.weixin.qq.com/s?__biz=MzA4MjU1MDk3Ng==&mid=2451526954&idx=1&sn=ba8e3b6788ae0a6f605cb9627e7b22e0&utm_source=tuicool&utm_medium=referral