b bst td

1.向线程PostMessage
  函数controlled_module_ex::postmessage完成消息推送。
  虚拟函数controlled_module_ex::message(const _command & cmd)实现消息接收。

1. #include "controlled_module_ex.hpp" 
2. class thdex: public controlled_module_ex 
3. { 
4. protected: 
5.     virtual void message(const _command & cmd) 
6.     { 
7.         controlled_module_ex::message(cmd); 
8.         if(cmd.nCmd==BM_USER+1) 
9.         { 
10.             cout << "get message" << endl; 
11.         } 
12.     } 
13. }; 
14.  
15. int _tmain(int argc, _TCHAR* argv[]) 
16. { 
17.     thdex t; 
18.     t.safestart(); 
19.     t.postmessage(BM_USER+1); 
20.     char buf[10]; 
21.     gets_s(buf,sizeof buf); 
22.     t.safestop(); 
23.     return 0; 
24. } 

2.向线程PostMessage，并携带简单对象参数
我们都知道常规的PostMessage要传参，如果是整型参数，还可以用强制转换，但如果是其他类型，例如字符串，我们就必须创建一个字符串缓冲，把缓冲指针作为参数传过去，线程还不能忘记删除，否则导致内存泄漏，自定义结构也是一样的操作，如果想尝试传递一个CString对象，是不可能的。
幸运的是boost提供了boost::any来抽象任何对象类型，controlled_module_ex的消息传递都是基于boost::any来完成，程序员可以由此写出干净而且内存安全的代码。

1. #include "controlled_module_ex.hpp" 
2.  
3. struct mystruct 
4. { 
5.     string a; 
6.     int b; 
7. }; 
8. class thdex: public controlled_module_ex 
9. { 
10. protected: 
11.     virtual void message(const _command & cmd) 
12.     { 
13.         controlled_module_ex::message(cmd); 
14.         if(cmd.nCmd==BM_USER+1) 
15.         { 
16. cout << "get integer:" << boost::any_cast<int>(cmd.anyParam) << endl; 
17.         } 
18.         if(cmd.nCmd==BM_USER+2) 
19.         { 
20. cout << "get string:" << boost::any_cast<string>(cmd.anyParam) << endl; 
21.         } 
22.         if(cmd.nCmd==BM_USER+3) 
23.         { 
24. mystruct par = boost::any_cast<mystruct>(cmd.anyParam); 
25. cout << "get mystruct:" << par.a << "," << par.b << endl; 
26.         } 
27.     } 
28. }; 
29.  
30. int _tmain(int argc, _TCHAR* argv[]) 
31. { 
32.     thdex t; 
33.     t.safestart(); 
34.     t.postmessage(BM_USER+1,123); 
35.     t.postmessage(BM_USER+2,string("hello world")); 
36.     mystruct par; 
37.     par.a = "hello world"; 
38.     par.b = 123; 
39.     t.postmessage(BM_USER+3,par); 
40.  
41.     char buf[10]; 
42.     gets_s(buf,sizeof buf); 
43.     t.safestop(); 
44.     return 0; 
45. } 

3.向线程PostMessage,并传递内存块参数
假如我们书写了一个录音子线程，如何将录制的语音数据传递给其他线程呢，常规做法是创建一个缓冲，将语音数据填充进去，然后将缓冲地址作为参数传递，这种做法要求接收线程不能忘记删除，否则会导致内存泄漏。
幸运的是boost提供了智能指针，可以类似java,c#的智能内存回收一样来管理内存分配，我们如果使用这个对象来作为参数传递，就可以完美的防范内存泄漏行为，就算子线程没有处理，别担心，内存它会自动回收的。

1. #include "controlled_module_ex.hpp" 
2.  
3. struct mystruct 
4. { 
5.     boost::shared_ptr<char> data; 
6.     int datalen; 
7. }; 
8. class thdex: public controlled_module_ex 
9. { 
10. protected: 
11.     virtual void message(const _command & cmd) 
12.     { 
13.         controlled_module_ex::message(cmd); 
14.         if(cmd.nCmd==BM_USER+1) 
15.         { 
16. cout << "get sharedptr" << endl; //仅仅得到数据，得不到数据长度 
17.         } 
18.         if(cmd.nCmd==BM_USER+2) 
19.         { 
20. mystruct par = boost::any_cast<mystruct>(cmd.anyParam); 
21. cout << "get sharedptr len:" << par.datalen << endl; 
22.         } 
23.     } 
24. }; 
25.  
26. int _tmain(int argc, _TCHAR* argv[]) 
27. { 
28.     thdex t; 
29.     t.safestart(); 
30.     t.postmessage(BM_USER+1,boost::shared_ptr<char>(new char[1000])); 
31.     mystruct par; 
32.     par.datalen = 1000; 
33.     par.data = boost::shared_ptr<char>(new char[par.datalen]); 
34.     t.postmessage(BM_USER+2,par); 
35.  
36.     char buf[10]; 
37.     gets_s(buf,sizeof buf); 
38.     t.safestop(); 
39.     return 0; 
40. } 

3.向线程SendMessage

函数controlled_module_ex::execute完成这个工作
虚拟函数controlled_module_ex::on_command(const unsigned int command,const boost::any par)响应消息处理

1. #include "controlled_module_ex.hpp" 
2.  
3. class thdex: public controlled_module_ex 
4. { 
5. protected: 
6.     boost::any on_command(const unsigned int command,const boost::any par) 
7.     { 
8.         if(command==1) 
9.         { 
10.             cout << "on command" << endl; 
11.             return 0; 
12.         } 
13.         if(command==2) 
14.         { 
15.             cout << "on command,par:" << boost::any_cast<string>(par) << endl; 
16.             return 0; 
17.         } 
18.         if(command==3) 
19.         { 
20.             return true; 
21.         } 
22.         else 
23.             return controlled_module_ex::on_command(command,par); 
24.     } 
25. }; 
26.  
27. int _tmain(int argc, _TCHAR* argv[]) 
28. { 
29.     thdex t; 
30.     t.safestart(); 
31.     t.execute(1,0);//等待子线程处理完成 
32.     t.execute(2,string("hello world"));//带参数 等待子线程完成 
33.     bool rs = boost::any_cast<bool>(t.execute(3,0));//等待子线程处理完成，并取得返回值 
34.     cout << "get thread result:" << rs << endl; 
35.     boost::any timeout = t.execute(4,0,1000);//等待子线程处理，超时1秒 
36.     if(timeout.empty()) 
37.         cout << "timeout " << endl; 
38.  
39.     char buf[10]; 
40.     gets_s(buf,sizeof buf); 
41.     t.safestop(); 
42.     return 0; 
43. } 

4.定时器
类似于CWnd::OnTimer，controlled_module_ex也提供一个虚拟函数virtual void on_timer(const controlled_timer * p);来处理定时

1. #include "controlled_module_ex.hpp" 
2. class thdex: public controlled_module_ex 
3. { 
4. protected: 
5.     virtual void on_timer(const controlled_timer *p) 
6.     { 
7.         cout << "ontimer" << endl; 
8.     } 
9. }; 
10.  
11. int _tmain(int argc, _TCHAR* argv[]) 
12. { 
13.     thdex t; 
14.     controlled_timer timer; 
15.     t.safestart(); 
16.     timer.starttimer(1000,&t); 
17.  
18.     char buf[10]; 
19.     gets_s(buf,sizeof buf); 
20.     t.safestop(); 
21.     return 0; 
22. }