改写 gtkmm 的线程为 boost 线程

zhujiang73

         
         以前写 gtkmm 程序，线程一般是这样的：

1. #include <iostream>
   
2. #include <queue>
   
3. #include <glibmm/threads.h>
   
4. #include <glibmm/random.h>
   
5. #include <glibmm/timer.h>
   
6. #include <glibmm/init.h>
   
7. namespace
   
8. {
   
9. class MessageQueue
   
10. {
    
11. public:
    
12.     MessageQueue();
    
13.     ~MessageQueue();
    
14.     void producer();
    
15.     void consumer();
    
16. private:
    
17.     Glib::Threads::Mutex mutex_;
    
18.     Glib::Threads::Cond cond_push_;
    
19.     Glib::Threads::Cond cond_pop_;
    
20.     std::queue<int> queue_;
    
21. };
    
22. MessageQueue::MessageQueue()
    
23. {}
    
24. MessageQueue::~MessageQueue()
    
25. {}
    
26. void MessageQueue::producer()
    
27. {
    
28.     Glib::Rand rand (1234);
    
29.     for(auto i = 0; i < 200; ++i)
    
30.     {
    
31.         {
    
32.             Glib::Threads::Mutex::Lock lock (mutex_);
    
33.             while(queue_.size() >= 64)
    
34.                 cond_pop_.wait(mutex_);
    
35.             queue_.push(i);
    
36.             std::cout << '*';
    
37.             std::cout.flush();
    
38.             cond_push_.signal();
    
39.         }
    
40.         if(rand.get_bool())
    
41.             continue;
    
42.         Glib::usleep(rand.get_int_range(0, 100000));
    
43.     }
    
44. }
    
45. void MessageQueue::consumer()
    
46. {
    
47.     Glib::Rand rand (4567);
    
48.     for(;;)
    
49.     {
    
50.         {
    
51.             Glib::Threads::Mutex::Lock lock (mutex_);
    
52.             while(queue_.empty())
    
53.                 cond_push_.wait(mutex_);
    
54.             const int i = queue_.front();
    
55.             queue_.pop();
    
56.             std::cout << "\x08 \x08";
    
57.             std::cout.flush();
    
58.             cond_pop_.signal();
    
59.             if(i >= 199)
    
60.                 break;
    
61.         }
    
62.         if(rand.get_bool())
    
63.             continue;
    
64.         Glib::usleep(rand.get_int_range(10000, 200000));
    
65.     }
    
66. }
    
67. }
    
68. int main(int, char**)
    
69. {
    
70.     Glib::init();
    
71.     MessageQueue queue;
    
72.     Glib::Threads::Thread *const producer = Glib::Threads::Thread::create(
    
73.             sigc::mem_fun(queue, &MessageQueue::producer));
    
74.     Glib::Threads::Thread *const consumer = Glib::Threads::Thread::create(
    
75.             sigc::mem_fun(queue, &MessageQueue::consumer));
    
76.     producer->join();
    
77.     consumer->join();
    
78.     std::cout << std::endl;
    
79.     return 0;
    
80. }
    

复制代码

现在想改用 boost 的线程。

zhujiang73

zhujiang73 发表于 2016-01-27 21:39
以前写 gtkmm 程序，线程一般是这样的：现在想改用 boost 的线程。

      查了些资料之后我写成这样了，写对了么？

1. #ifndef MCVTHREAD_H
   
2. #define MCVTHREAD_H
   
3. 
   
4. #include <boost/thread/thread.hpp>
   
5. #include <boost/thread/mutex.hpp>
   
6. #include <boost/thread/shared_mutex.hpp>
   
7. #include <boost/thread/condition.hpp>
   
8. #include <boost/function/function0.hpp>
   
9. 
   
10. #include <glibmm.h>
    
11. #include <algorithm>
    
12. #include <functional>
    
13. #include <iostream>
    
14. #include <vector>
    
15. #include <queue>
    
16. #include <string>
    
17. #include <unistd.h>
    
18. 
    
19. class  WebWin;
    
20. 
    
21. class  McvThread
    
22. {
    
23. public:
    
24.     McvThread(){};
    
25.     ~McvThread(){};
    
26. 
    
27. protected:
    
28.     Glib::Dispatcher            signal_thread;
    
29.     std::queue<std::string>     str_queue_events;
    
30.     //Glib::Threads::Mutex      mcv_mutex;
    
31.     boost::shared_mutex         shr_mutex;
    
32.     boost::condition            cond;
    
33. 
    
34.     int   num;
    
35. 
    
36. public:
    
37.     void setup(WebWin  *p_webwin);
    
38.     void start();
    
39.     void get_str_event(std::string  &str_event);
    
40. 
    
41. protected:
    
42.     void fun();
    
43. };
    
44. 
    
45. 
    
46. #endif // MCVTHREAD_H
    

复制代码

1. #include "webwin/webwin.h"
   
2. #include "mcvthread/mcvthread.h"
   
3. 
   
4. #include <cstdlib>
   
5. #include <cstring>
   
6. #include <cstdio>
   
7. 
   
8. void McvThread::setup(WebWin  *p_webwin)
   
9. {
   
10.     num = 0;
    
11.     signal_thread.connect(sigc::bind<1>(sigc::mem_fun(*p_webwin, &WebWin::on_thread_signal), this));
    
12. }
    
13. 
    
14. void McvThread::fun()
    
15. {
    
16.     for (int i=0; i<200; i++)
    
17.     {
    
18.         for (int i=0; i<10; i++) usleep(100*1000);
    
19. 
    
20.         //usleep(1000);
    
21. 
    
22.         //sleep(1);
    
23. 
    
24.         num++;
    
25. 
    
26.         char           ch_text[1024];
    
27.         std::string    str_text;
    
28. 
    
29.         shr_mutex.lock();
    
30. 
    
31.         if (str_queue_events.size() > 0)  cond.wait(shr_mutex);
    
32. 
    
33.         {
    
34.             snprintf(ch_text, 1000, "Thread num : %d    ", num);
    
35.             str_text = ch_text;
    
36.             snprintf(ch_text, 1000, "queue_events.size : %d    ", str_queue_events.size());
    
37.             str_text += ch_text;
    
38.             str_queue_events.push(str_text);
    
39.         }
    
40. 
    
41.         shr_mutex.unlock();
    
42. 
    
43.         signal_thread();
    
44.     }
    
45. }
    
46. 
    
47. void McvThread::start()
    
48. {
    
49.     boost::function0<void> f = boost::bind(&McvThread::fun, this);
    
50.     boost::thread thrd(f);
    
51. }
    
52. 
    
53. void McvThread::get_str_event(std::string  &str_event)
    
54. {
    
55.     shr_mutex.lock();
    
56.     //shr_mutex.lock_shared();
    
57. 
    
58.     if (str_queue_events.size() > 0)
    
59.     {
    
60.         str_event = str_queue_events.front();
    
61.         str_queue_events.pop();
    
62.     }
    
63.     shr_mutex.unlock();
    
64.     //shr_mutex.unlock_shared();
    
65. 
    
66.     cond.notify_one();
    
67. }
    
68. 
    

复制代码

1.     McvThread  *p_mcv_thread = new McvThread();
   
2. 
   
3.     //p_mcv_thread->signal_thread.connect(sigc::mem_fun(*this, &WebWin::on_thread_signal));
   
4. 
   
5.     p_mcv_thread->setup(this);
   
6.     p_mcv_thread->start();
   

复制代码

1. 
   
2. void WebWin::on_thread_signal(McvThread  *p_mcv_thread)
   
3. {
   
4.     std::string  str_event = "";
   
5. 
   
6.     p_mcv_thread->get_str_event(str_event);
   
7. 
   
8.     std::cout << str_event << std::endl;
   
9. }
   

复制代码

fender0107401

貌似，只要gtkmm库的代码运行在自己的thread上就行了，至于用哪个库的thread都不是问题吧。

fender0107401

我写的gtkmm的程序，好像都是用的boost的线程。

zhujiang73

fender0107401 发表于 2016-01-28 08:49
我写的gtkmm的程序，好像都是用的boost的线程。

      我现在是工作线程用 boost 线程实现，但是工作线程向 GUI 线程发消息是用 Gtkmm 中的 Glib Dispatcher 跨线程消息机制。

      程序跑起来也没发现什么问题，就是不知道 Gtkmm 和 Boost 配合使用时有没有坑？    

fender0107401

回复 5# zhujiang73

差不多，我也是这么弄的。

我在gui里面弄了个带锁的队列，每次发消息就往队列里面加一个事务，然后emit一下，让处理事务的代码去处理一个事务，而且处理的时候是运行在gui的线程上面。

   

zhujiang73

回复 6# fender0107401


   

Glib Dispatcher works similar to sigc::signal<void>. But unlike normal signals, the notification happens asynchronously through a pipe.

    这个跨线程的异步消息，看起来就是个进程间通信机制。不知道 Boost 里有没有类似的东西？