[c++]类和线程怎么结合｛有码）

sonicling

回复 10# inet_addr


    静态函数只是个面向库的接口而已，是private不对外的。里面调用线程类的实际工作函数

1. class thread
   
2. {
   
3. public:
   
4.      virtual void run() = 0;
   
5. private:
   
6.      static void *thread_proc(thread *thrd)
   
7.     {
   
8.         thrd->run();
   
9.     }
   
10. };
    
11. 
    
12. class my_thread : public thread
    
13. {
    
14. public:
    
15.     void run()
    
16.     {
    
17.         // 这才是实际干事情的地方
    
18.     }
    
19. }
    
20. 
    

复制代码

群雄逐鹿中原

尔等根本体会不到写C++的乐趣

1. 
   
2. #include <my_pthread.h>
   
3. #include <stdio.h>
   
4. 
   
5. struct foo
   
6. {
   
7.     int n;
   
8.     void *test(void *arg)
   
9.     {
   
10.         for(int i = 0; i < 10; ++i)
    
11.             printf("%d \n", ++n);
    
12.                 return NULL;
    
13.     }
    
14. };
    
15. 
    
16. int main()
    
17. {
    
18.     foo f;
    
19.     pthread_t id;
    
20.     my_pthread_create(&f, &id, NULL, &foo::test, NULL);
    
21.     pthread_join(id, NULL);
    
22.     return 0;
    
23. }
    

复制代码

以下为 my_pthread.h

1. 
   
2. #ifndef INC_THREAD_PROXY_H_
   
3. #define INC_THREAD_PROXY_H_
   
4. 
   
5. #include <pthread.h>
   
6. #include <semaphore.h>
   
7. 
   
8. template <class T>
   
9. class thread_proxy_imp
   
10. {
    
11. protected:
    
12.     typedef struct
    
13.     {
    
14.         void *(T::*start_routine_)(void *);
    
15.         void      *arg_;
    
16.         T         *obj_;
    
17.         sem_t      sem_;
    
18.     } thread_param;
    
19. 
    
20.     static void *thread_proxy_entry(void *arg)
    
21.     {
    
22.         thread_param *param_ptr = reinterpret_cast<thread_param *>(arg);
    
23.         thread_param  param     = *param_ptr;
    
24.         sem_post(&param.sem_);
    
25.         return (param.obj_->*param.start_routine_)(param.arg_);
    
26.     }
    
27. 
    
28. public:
    
29.     int create(
    
30.         T                    *obj,
    
31.         pthread_t            *thread,
    
32.         const pthread_attr_t *attr,
    
33.         void            *(T::*start_routine) (void *),
    
34.         void                 *arg)
    
35.     {
    
36.         int rt;
    
37.         thread_param param = {start_routine, arg, obj};
    
38.         
    
39.         sem_init(&param.sem_, 0, 0);
    
40.         rt = pthread_create(thread,
    
41.                             attr,
    
42.                                                         thread_proxy_imp::thread_proxy_entry,
    
43.                                                         reinterpret_cast<void *>(&param));
    
44.         if(rt == 0) sem_wait(&param.sem_);
    
45.         sem_destroy(&param.sem_);
    
46.         return rt;
    
47.     }
    
48. };
    
49. 
    
50. 
    
51. template<class T>
    
52. int my_pthread_create(
    
53.         T                    *obj,
    
54.     pthread_t            *thread,
    
55.     const pthread_attr_t *attr,
    
56.     void            *(T::*start_routine) (void *),
    
57.     void                 *arg)
    
58. {
    
59.     return thread_proxy_imp<T>().create(obj, thread, attr, start_routine, arg);
    
60. }
    
61. 
    
62. #endif
    
63. 
    
64. 
    
65. 
    

复制代码

群雄逐鹿中原

nilgod 发表于 2012-06-21 15:39
目前看起来感觉使用lambda似乎看起来更优秀。

pthread_pthread 如何结合lambda用，请教。。

群雄逐鹿中原

回复 16# nilgod

是吗，还是第一次有人这么批评我的。

那我等着，你有货拿出来遛遛，别太监了。
   

群雄逐鹿中原

回复 19# nilgod

没事。我最喜欢看到真实的意见了。
不过，你说一塌糊涂和烂，要具体的指明烂之所在。
这个不影响你装系统吧。
   

群雄逐鹿中原

nigod哑炮了？真是个二货。

群雄逐鹿中原

晕啊，我不好在哪里啊，就凭你感觉？！真是个二货没错。。

群雄逐鹿中原

回复 24# nilgod


    我原本等着你指出我的不足，好好切磋一下，
结果发现不靠谱。

你说 “第一是感觉，第二是你整个就不好。",
这是什么狗屁理由啊

sonicling

关注点不一样，封装自然不同。

只关注任务本身，不关心线程，像群雄逐鹿中原那么封装比较好。但是要对线程进行操作，自然是nilgod的封装比较好。

有一点是互通的，那就是用静态函数进行转接。

群雄逐鹿中原

好吧，为了让某些网友服气点，我再多罗嗦两点

1. 逐鹿在13楼的封装，很简单，
   就是针对楼主的需求，对于类里的线程函数，
   只要加上类对象 f 就行了，除此之外没有别的功能。
    my_pthread_create(&f, &id, NULL, &foo::test, NULL);
   几乎和原生的pthread_create函数一样用法，简单上手。
   
2. 某网友在22楼的代码，class和thread结合，
   里面有一个极其典型的bug，
   就是构造函数启动线程，线程调用虚函数。
   构造函数里调用：
      Start(process, stackSize, isSuspended);
   Start线程后，用virtual
      virtual DWORD Run();
   
   这个bug相当典型，并且是一般情况下不出现，偶尔出一下会要命，
   不注意的人极难找到。
   
为什么逐鹿如此肯定这个bug呢？
为什么逐鹿在13楼用小清新的封装办法呢？
你不被这样的事情折磨几次，不会明白的。