C++实现仿安卓线程Handler、Message、Looper的功能

在java开发中，风俗使用Handler、Message来处置惩罚同步，比如对相机的利用(open、setParamters、start、stop、clost)全部抛到同一个线程处置惩罚，防止并发利用导致非常，如许保存给外部的同一接口就是安全的，无论外部哪些线程来调用，终极到控制模块都是在同一线程处置惩罚相机利用。这里提供一个C++实现的Handler Message封装，可以实现类似安卓那样的接口；
Handler类封装：

3. #ifndef _CPP_THREADHANDLER_H
4. #define _CPP_THREADHANDLER_H
6. #include <algorithm>
7. #include <chrono>
8. #include <condition_variable>
9. #include <functional>
10. #include <iostream>
11. #include <list>
12. #include <map>
13. #include <memory>
14. #include <mutex>
15. #include <thread>
16. #include "Message.h"
18. class ThreadHandler {
19.    public:
20.     using TimePoint_t = std::chrono::steady_clock::time_point;
21.     using Clock_t = std::chrono::steady_clock;
22.     using MillisDuration_t = std::chrono::milliseconds;
23.     using Task = std::function<void(const Message& msg)>;
25.     ThreadHandler() : _stoped(false) { initLoop(); }
27.     ~ThreadHandler() {
28.         _stoped = true;
29.         _cond.notify_all();
30.         _looper.join();
31.     }
33.     void setName(const std::string n) { this->name = n; }
35.     bool sendEmptyMessageDelay(int what, long delay_millis) {
36.         if (what < 0 || delay_millis < 0)
37.             return false;
38.         Message msg(what, delay_millis);
40.         std::unique_lock<std::mutex> lock(_queue_lock);
41.         _msg_list.push_back(msg);
42.         _msg_list.sort(std::less<Message>());
43.         _cond.notify_all();
44.         return true;
45.     }
47.     bool sendEmptyMessageDelay(int what) {
48.         return sendEmptyMessageDelay(what, 0);
49.     }
51.     bool postDelay(std::function<void()>&& f, long delay_millis) {
52.         if (f == nullptr || delay_millis < 0) {
53.             return false;
54.         }
55.         std::unique_lock<std::mutex> lock(_queue_lock);
56.         Message msg(0, delay_millis);
57.         msg.onRun(std::move(f));
58.         _msg_list.push_back(msg);
59.         _msg_list.sort(std::less<Message>());
60.         _cond.notify_all();
61.         return true;
62.     }
64.     bool post(std::function<void()>&& f) { return postDelay(std::move(f), 0); }
66.     void removeMessages(int what) {
67.         if (what < 0)
68.             return;
70.         std::unique_lock<std::mutex> lock(_queue_lock);
71.         if (!_msg_list.empty())
72.             _msg_list.remove_if(
73.                 [what](const Message& m) { return m.what == what; });
74.     }
76.     void removeAlls() {
77.         std::unique_lock<std::mutex> lock(_queue_lock);
78.         if (!_msg_list.empty())
79.             _msg_list.clear();
81.         printf("ThreadHandler::removeAlls name: %s",
82.                                  name.c_str());
83.     }
85.     void stop() {
86.         _stoped = true;
87.         _cond.notify_all();
88.         printf("ThreadHandler::stop name: %s", name.c_str());
89.     }
91.     void handleMessage(Task&& cb) { _callback = cb; }
93.    private:
94.     void dispatchMessage(const Message& msg) const {
95.         if (msg.task != nullptr) {
96.             msg.task();
97.         } else {
98.             if (msg.what < 0 || _callback == nullptr)
99.                 return;
100.             _callback(msg);
101.         }
102.     }
104.     void initLoop() {
105.         _looper = std::thread([this]() {
106.             while (true) {
107.                 Message msg;
108.                 bool isFired = false;
109.                 {
110.                     std::unique_lock<std::mutex> lock(_queue_lock);
111.                     if (_msg_list.empty()) {
112.                         _cond.wait(lock, [this] {
113.                             return _stoped || !_msg_list.empty();
114.                         });
115.                     } else {
116.                         auto front = _msg_list.front();
117.                         // 如果要when 大于 当前时间，则休眠；否则继续往下执行
118.                         if (front.when > Clock_t::now()) {
119.                             if (front.when > Clock_t::now() + maxSleepTime) {
120.                                 printf(
121.                                     "ThreadHandler::initLoop time too long name: %s, when: "
122.                                     "%s ,now: %s , maxSleepTime: %s",
123.                                     name.c_str(),
124.                                     std::to_string(
125.                                         std::chrono::duration_cast<
126.                                             std::chrono::seconds>(
127.                                             front.when.time_since_epoch())
128.                                             .count())
129.                                         .c_str(),
130.                                     std::to_string(
131.                                         std::chrono::duration_cast<
132.                                             std::chrono::seconds>(
133.                                             Clock_t::now().time_since_epoch())
134.                                             .count())
135.                                         .c_str(),
136.                                     std::to_string(
137.                                         std::chrono::duration_cast<
138.                                             std::chrono::seconds>(maxSleepTime)
139.                                             .count())
140.                                         .c_str());
141.                             }
143.                             _cond.wait_until(lock, front.when, [this] {
144.                                 return _stoped || (!_msg_list.empty() &&
145.                                                    _msg_list.front().when <= Clock_t::now());
146.                             });
147.                         }
148.                     }
149.                     if (!_stoped && _msg_list.empty())
150.                         continue;
151.                     if (_stoped) {
152.                         _msg_list.clear();
153.                         return;
154.                     }
155.                     // List的头结点的时间小于等于当前时间，则执行头结点任务
156.                     if (_msg_list.front().when <= Clock_t::now()) {
157.                         msg = std::move(_msg_list.front());
158.                         _msg_list.pop_front();
159.                         isFired = true;
160.                     }
161.                 }
162.                 if (isFired) {
163.                     dispatchMessage(msg);
164.                 }
165.             }
166.         });
167.     }
169.     bool _stoped;
170.     std::string name;
171.     std::list<Message> _msg_list;
172.     std::mutex _queue_lock;
173.     std::condition_variable _cond;
174.     std::thread _looper;
175.     Task _callback;
176.     std::chrono::minutes maxSleepTime{4};
177. };
179. #endif  // _CPP_THREADHANDLER_H

复制代码

Message实现类：

3. #ifndef _CPP_MESSAGE_H
4. #define _CPP_MESSAGE_H
5. #include <chrono>
6. #include <condition_variable>
7. #include <functional>
8. #include <iostream>
9. #include <list>
10. #include <map>
11. #include <memory>
12. #include <mutex>
13. #include <thread>
15. class Message {
16.    public:
17.     using TimePoint_t = std::chrono::steady_clock::time_point;
18.     using Clock_t = std::chrono::steady_clock;
19.     using MillisDuration_t = std::chrono::milliseconds;
21.     int what;
22.     int m_arg1;
23.     int m_arg2;
24.     std::function<void()> task;
25.     TimePoint_t when;
27.     Message() : Message(-1, 0) {}
29.     Message(int what) : Message(what, 0) {}
31.     Message(int what, long delayMillis)
32.         : what(what), when(Clock_t::now() + MillisDuration_t(delayMillis)) {
33.         task = nullptr;
34.     }
36.     Message(const Message& msg)
37.         : what(msg.what), task(msg.task), when(msg.when) {}
39.     Message(Message&& msg) : what(msg.what), task(msg.task), when(msg.when) {}
41.     ~Message() {}
43.     Message& operator=(const Message& msg) {
44.         this->what = msg.what;
45.         this->when = msg.when;
46.         this->task = msg.task;
48.         return *this;
49.     }
51.     Message& operator=(Message&& msg) {
52.         this->what = msg.what;
53.         this->when = msg.when;
54.         this->task = std::move(msg.task);
55.         return *this;
56.     }
58.     void setWhen(long delayMillis) {
59.         when = Clock_t::now() + MillisDuration_t(delayMillis);
60.     }
62.     void onRun(std::function<void()>&& f) { this->task = f; }
64.     bool operator>(const Message& msg) const { return (this->when > msg.when); }
66.     bool operator<(const Message& msg) const { return (this->when < msg.when); }
68.     bool operator==(const Message& msg) const {
69.         return (this->what == msg.what) && (this->task != nullptr) &&
70.                (msg.task != nullptr);
71.     }
73.     bool operator==(int what) const { return (this->what == what); }
74. };
76. #endif  // _CPP_MESSAGE_H

复制代码

使用方法：
//构造函数或类初始化中设置如下
mHandler.setName("classATh");
mHandler.handleMessage([&](const Message& msg) { handleMessage(msg); });

void classATh::handleMessage(const Message& msg) {
    if (msg.what == MSG_CODE_QUERY_DEVICE_INFO) {
        //
    } else if (msg.what == MSG_CODE_TRADE_INIT) {
      //
    } else if (msg.what == MSG_CODE_DEVICE_HEART_BEAT) {
        heartBeat();
    }
}
void classATh::startHearBeat() {
    mHandler.removeMessages(MSG_CODE_DEVICE_HEART_BEAT);
    mHandler.sendEmptyMessageDelay(MSG_CODE_DEVICE_HEART_BEAT, 60 * 1000);
}

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金