C++11 std thread 和 gtkmm 的跨线程消息

zhujiang73

          C++11  里终于有了 std::thread 线程但是好像还是没有跨线程消息，也没有消息循环机制，试了试 std::thread 配合 gtkmm 的跨线程消息。

          目前程序工作正常...  

1. 
   
2. #include <glibmm.h>
   
3. #include <algorithm>
   
4. #include <functional>
   
5. #include <iostream>
   
6. #include <vector>
   
7. #include <queue>
   
8. #include <string>
   
9. #include <unistd.h>
   
10. #include <thread>
    
11. #include <mutex>
    
12. #include <condition_variable>
    
13. 
    
14. class  McvApp;
    
15. 
    
16. class  McvThread
    
17. {
    
18. public:
    
19.     McvThread() {};
    
20.     ~McvThread() {};
    
21. 
    
22. protected:
    
23.     int                         num;
    
24. 
    
25.     Glib::Dispatcher            signal_thread_work;
    
26.     Glib::Dispatcher            signal_thread_exit;
    
27. 
    
28.     std::queue<std::string>     str_queue_events;
    
29.     std::mutex                  m_mutex;
    
30.     std::condition_variable     m_cond;
    
31. 
    
32.     std::thread                *p_thread;
    
33. 
    
34.     void  fun();
    
35. 
    
36. public:
    
37.     void setup(McvApp  *p_mapp);
    
38.     void get_str_event(std::string  &str_event);
    
39.     void start();
    
40.     void m_join();
    
41. };
    
42. 
    
43. 
    
44. class McvApp : public sigc::trackable
    
45. {
    
46. public:
    
47.     McvApp()
    
48.     {
    
49.         main_loop = Glib::MainLoop::create();
    
50.     };
    
51.     ~McvApp() {};
    
52.     void run_main_loop();
    
53.     void on_thread_signal(McvThread  *p_mcv_thread);
    
54.     void on_thread_exit(McvThread  *p_mcv_thread);
    
55. 
    
56. private:
    
57.     Glib::RefPtr<Glib::MainLoop>  main_loop;
    
58. };
    
59. 
    
60. void McvThread::setup(McvApp  *p_mapp)
    
61. {
    
62.     num = 0;
    
63.     signal_thread_work.connect(sigc::bind<1>(sigc::mem_fun(*p_mapp, &McvApp::on_thread_signal), this));
    
64.     signal_thread_exit.connect(sigc::bind<1>(sigc::mem_fun(*p_mapp, &McvApp::on_thread_exit), this));
    
65. }
    
66. 
    
67. void McvThread::start()
    
68. {
    
69.       p_thread = new std::thread(&McvThread::fun, this);
    
70. }
    
71. 
    
72. void McvThread::m_join()
    
73. {
    
74.       p_thread->join();
    
75. }
    
76. 
    
77. void McvThread::fun()
    
78. {
    
79.     for (int i=0; i<200; i++)
    
80.     {
    
81.         //for (int i=0; i<10; i++) usleep(100*1000);
    
82. 
    
83.         std::this_thread::sleep_for(std::chrono::milliseconds(100));
    
84. 
    
85.         num++;
    
86. 
    
87.         char           ch_text[1024];
    
88.         std::string    str_text;
    
89. 
    
90.         std::unique_lock<std::mutex> lock(m_mutex);
    
91. 
    
92.         if (str_queue_events.size() > 0)  m_cond.wait(lock);
    
93. 
    
94.         snprintf(ch_text, 1000, "McvThread num : %d    ", num);
    
95.         str_text = ch_text;
    
96.         snprintf(ch_text, 1000, "queue_events.size : %d    ", str_queue_events.size());
    
97.         str_text += ch_text;
    
98.         str_queue_events.push(str_text);
    
99. 
    
100.         lock.unlock();
     
101. 
     
102.         signal_thread_work();
     
103.     }
     
104. 
     
105.     signal_thread_exit();
     
106. }
     
107. 
     
108. void McvThread::get_str_event(std::string  &str_event)
     
109. {
     
110.     std::unique_lock<std::mutex> lock(m_mutex);
     
111. 
     
112.     if (str_queue_events.size() > 0)
     
113.     {
     
114.         str_event = str_queue_events.front();
     
115.         str_queue_events.pop();
     
116.     }
     
117. 
     
118.     lock.unlock();
     
119. 
     
120.     m_cond.notify_one();
     
121. }
     
122. 
     
123. void McvApp::run_main_loop()
     
124. {
     
125.     main_loop->run();
     
126. }
     
127. 
     
128. void McvApp::on_thread_signal(McvThread  *p_mcv_thread)
     
129. {
     
130.     std::string  str_event = "";
     
131. 
     
132.     p_mcv_thread->get_str_event(str_event);
     
133. 
     
134.     std::cout << str_event << std::endl;
     
135. }
     
136. 
     
137. void McvApp::on_thread_exit(McvThread  *p_mcv_thread)
     
138. {
     
139.     p_mcv_thread->m_join();
     
140. 
     
141.     main_loop->quit();
     
142. }
     
143. 
     
144. int main(int, char**)
     
145. {
     
146.     Glib::init();
     
147. 
     
148.     McvApp *p_app = new McvApp();
     
149. 
     
150.     McvThread    *p_mcv_thread = new McvThread();
     
151. 
     
152.     p_mcv_thread->setup(p_app);
     
153.     p_mcv_thread->start();
     
154. 
     
155.     p_app->run_main_loop();
     
156. 
     
157.     std::cout << "main_loop quit. " << std::endl;
     
158. 
     
159.     return 0;
     
160. }
     

复制代码