1.封装遇到的问题

       将Pthreads线程封装为抽象类，这样用户在使用线程时，只需要继承一下这个抽象类，并实现相应的接口就可以了。这样做的好处是用户可以将注意力集中在线程所要执行的逻辑上，而不需要关注创建线程、销毁线程等细节问题上。这里给出两种简单的封装方法，以供参考。

       我们抽象类的名称为Thread，其中有一个成员函数run，该函数为的声明形式为：

       void run() = 0;

       即将该成员函数声明为纯虚函数，用户继承此类必须要实现此成员函数。Thread中还有另外一个成员函数start，该函数的声明形式为：

       void start();

       用户在子类中调用start方法，将启动线程，并在线程中执行run函数。

       最常想到的方法就是在start方法中使用pthread_create创建一个线程，并调用run函数。如下面这样的实现：

    

1. void start() 
2.  
3.     { 
4.  
5.            int status; 
6.  
7.            status = pthread_create(_pThread,NULL,Thread::run,NULL); 
8.  
9.            if(status != 0) 
10.  
11.                   err_abort(“creating thread failure”,status); 
12.  
13.     } 

       这样编译肯定是不能通过的，这是因为pthread_create要求的线程例程的接口形式为：

       void *(*thread_routin)(void *args);

       而上面代码中提供的线程例程的接口形式为：

       void Thread::run()

       显然不符合要求的接口。

       为了能够在start中调用run函数，我们不得不采用一种迂回的方式。下面提供两种方法：一种是使用静态成员函数，另外一种是使用友元函数。

       静态成员函数的作用域是全局的，而不仅仅局限于某个函数中。静态成员函数的实现方法和C语言中的普通函数类似，因此静态函数没有this指针，静态函数只能操作静态成员变量。之所以将静态函数封装到类中，在很大程度上也只是为了满足面向对象的特性之一-----封装性。

2.使用静态函数

       下面是一个简单的使用静态成员函数调用类中某个函数的例子，这个例子仅仅作为一个引子：

 

1. /* 
2.  
3.  * main.cpp 
4.  
5.  * 
6.  
7.  *  Created on: Jul 24, 2012 
8.  
9.  *      Author: lichao 
10.  
11.  */ 
12.  
13. #include <iostream> 
14.  
15. #include <pthread.h> 
16.  
17. #include <time.h> 
18.  
19. #include "lc_error.h" 
20.  
21.   
22.  
23. using namespace std; 
24.  
25.   
26.  
27. class MyThread 
28.  
29. { 
30.  
31. public: 
32.  
33.        void run() 
34.  
35.        { 
36.  
37.               fprintf(stdout,"I'm a little tired.Sleep for a while.\n"); 
38.  
39.               fflush(stdout); 
40.  
41.               sleep(5); 
42.  
43.        } 
44.  
45.        static void * thread_proxy_func(void * args) 
46.  
47.        { 
48.  
49.               MyThread * pMyThread = static_cast<MyThread *>(args); 
50.  
51.               pMyThread->run(); 
52.  
53.               return NULL; 
54.  
55.        } 
56.  
57.        virtual ~MyThread(){} 
58.  
59. }; 
60.  
61.   
62.  
63. int main(int argc,char *argv[]) 
64.  
65. { 
66.  
67.        MyThread t; 
68.  
69.        pthread_t thread; 
70.  
71.        int status; 
72.  
73.        status = pthread_create(&thread,NULL,MyThread::thread_proxy_func,(void *)&t); 
74.  
75.        if(status != 0) 
76.  
77.               err_abort("creating thread error...\n",status); 
78.  
79.        status = pthread_join(thread,NULL); 
80.  
81.        if(status != 0) 
82.  
83.               err_abort("joining thread...\n",status); 
84.  
85.        return 0; 
86.  
87. } 

       需要特别注意的是mian函数中使用pthread_create的执行例程为MyThread类中的线程代理函数thread_proxy_func，在此函数中在调用run函数，这样就顺利的迂回到了run函数。基于这种方法，我们可以用静态函数来封装一个简单的抽象类，以下为封装的代码，由三个文件构成：Thread.h（类的声明文件），Thread.cpp（类的实现文件），main.cpp（测试文件）：

 

1.       /* 
2.  
3.  * Thread.h 
4.  
5.  * 
6.  
7.  *  Created on: Jul 24, 2012 
8.  
9.  *      Author: lichao 
10.  
11.  */ 
12.  
13.   
14.  
15. #ifndef THREAD_H_ 
16.  
17. #define THREAD_H_ 
18.  
19.   
20.  
21. #include "lc_error.h" 
22.  
23. #include <pthread.h> 
24.  
25.   
26.  
27. class Thread 
28.  
29. { 
30.  
31. public: 
32.  
33.        Thread(); 
34.  
35.        ~Thread(); 
36.  
37.        virtual void run() = 0; 
38.  
39.        void start(); 
40.  
41.        void wait();       
42.  
43. private: 
44.     static void * thread_proxy_func(void *args); 
45.  
46.        pthread_t * _pThread; 
47.  
48. }; 
49.  
50.   
51.  
52.   
53.  
54. #endif /* THREAD_H_ */ 

 

 

1. /* 
2.  
3.  * Thread.cpp 
4.  
5.  * 
6.  
7.  *  Created on: Jul 24, 2012 
8.  
9.  *      Author: lichao 
10.  
11.  */ 
12.  
13.   
14.  
15. #include "Thread.h" 
16.  
17.   
18.  
19. Thread::Thread() 
20.  
21. { 
22.  
23.        _pThread = (pthread_t *)malloc(sizeof(pthread_t)); 
24.  
25.        if(NULL == _pThread) 
26.  
27.               error_abort("malloc error...\n"); 
28.  
29. } 
30.  
31.   
32.  
33. Thread::~Thread() 
34.  
35. { 
36.  
37.        if(NULL != _pThread) 
38.  
39.               delete _pThread; 
40.  
41. } 
42.  
43.   
44.  
45. void Thread::start() 
46.  
47. { 
48.  
49.        int status; 
50.  
51.        status = pthread_create(_pThread,NULL,thread_proxy_func,this); 
52.  
53.  
54.        if(status != 0) 
55.  
56.               err_abort("creating thread...\n",status); 
57.  
58. } 
59.  
60.   
61.  
62. void * Thread::thread_proxy_func(void *args) 
63.  
64. { 
65.  
66.        Thread * pThread = static_cast<Thread *>(args); 
67.  
68.        pThread->run(); 
69.  
70.        return NULL; 
71.  
72. } 
73.  
74.   
75.  
76. void Thread::wait() 
77.  
78. { 
79.  
80.        int status; 
81.  
82.        status = pthread_join(*_pThread,NULL); 
83.  
84.        if(status != 0) 
85.  
86.               err_abort("joining thread error...\n",status); 
87.  
88. } 

 

3.使用友元函数

       友元函数的作用和静态函数相同，都起到一个代理的作用。需要将对象的指针作为参数传递给这个友元函数，然后在友元函数中调用run函数。代码如下，

由三个文件构成：Thread.h（类的声明文件），Thread.cpp（类的实现文件），main.cpp（测试文件）：

 

1. /* 
2.  
3.  * Thread.h 
4.  
5.  * 
6.  
7.  *  Created on: Jul 24, 2012 
8.  
9.  *      Author: lichao 
10.  
11.  */ 
12.  
13.   
14.  
15. #ifndef THREAD_H_ 
16.  
17. #define THREAD_H_ 
18.  
19.   
20.  
21. #include "lc_error.h" 
22.  
23. #include <pthread.h> 
24.  
25.   
26.  
27. class Thread 
28.  
29. { 
30.  
31. public: 
32.  
33.        friend void * proxy_thread_func(void * args); 
34.  
35.        Thread(); 
36.  
37.        virtual ~Thread(); 
38.  
39.        void start(); 
40.  
41.        virtual void run(void) = 0; 
42.  
43.        void wait(); 
44.  
45. private: 
46.  
47.        pthread_t * _thread; 
48.  
49. }; 
50.  
51.   
52.  
53. void * proxy_thread_func(void * args); 
54.  
55.   
56.  
57. #endif /* THREAD_H_ */ 

 

 

1. /* 
2.  
3.  * Thread.cpp 
4.  
5.  * 
6.  
7.  *  Created on: Jul 24, 2012 
8.  
9.  *      Author: lichao 
10.  
11.  */ 
12.  
13.   
14.  
15. #include "Thread.h" 
16.  
17.   
18.  
19. void * proxy_thread_func(void * args) 
20.  
21. { 
22.  
23.        Thread * _thread = static_cast<Thread *>(args); 
24.  
25.        _thread->run(); 
26.  
27.        return NULL; 
28.  
29. } 
30.  
31.   
32.  
33. Thread::Thread() 
34.  
35. { 
36.  
37.        _thread = (pthread_t * )malloc(sizeof(pthread_t)); 
38.  
39.        if(NULL == _thread) 
40.  
41.               error_abort("malloc failure...\n"); 
42.  
43. } 
44.  
45.   
46.  
47. Thread::~Thread() 
48.  
49. { 
50.  
51.        if(_thread != NULL) 
52.  
53.               delete _thread; 
54.  
55. } 
56.  
57.   
58.  
59. void Thread::start() 
60.  
61. { 
62.  
63.        int status; 
64.  
65.        status = pthread_create(_thread,NULL,proxy_thread_func,this); 
66.  
67.        if(status != 0) 
68.  
69.               err_abort("creating thread error...\n",status); 
70.  
71. } 
72.  
73.   
74.  
75. void Thread::wait() 
76.  
77. { 
78.  
79.        int status; 
80.  
81.        status = pthread_join(*_thread,NULL); 
82.  
83.        if(status != 0) 
84.  
85.               err_abort("joing thread...\n",status); 
86.  
87. } 

1. /* 
2.  
3.  * main.c 
4.  
5.  * 
6.  
7.  *  Created on: Jul 24, 2012 
8.  
9.  *      Author: lichao 
10.  
11.  */ 
12.  
13.   
14.  
15. #include "Thread.h" 
16.  
17. #include <iostream> 
18.  
19. #include <time.h> 
20.  
21. using namespace std; 
22.  
23.   
24.  
25. class MyThread:public Thread 
26.  
27. { 
28.  
29. public: 
30.  
31.        void run() 
32.  
33.        { 
34.  
35.               cout<<"I'm a littile tired. Sleep for a while..."<<endl; 
36.  
37.               sleep(5); 
38.  
39.        } 
40.  
41.        virtual ~MyThread(){} 
42.  
43. }; 
44.  
45.   
46.  
47. int main(int argc,char *argv[]) 
48.  
49. { 
50.  
51.        MyThread t; 
52.  
53.        t.start(); 
54.  
55.        t.wait(); 
56.  
57.        return 0; 
58.  
59. }