线程的入口函数总结

http://blog.youkuaiyun.com/aguiwang/article/details/6937243

线程的入口函数种类大致如下：

 

在C程序当中线程的入口函数就是全局函数，这种方式也可以在C++里面继续延用。在C++里面还有其它形式的函数可以作为线程的入口函数，相对而且比C的全局函数更符合封装的思想。下面我们一一介绍：

 

一、全局函数作为线程的入口函数：可以通过传递对象的this指针来实现访问对象的public成员

[cpp]  view plain copy

1. unsigned ThreadFunc(void* lparam);)//全局函数  
2.   
3.   
4. class CThread  
5. {  
6. public:  
7.     CThread(int i,int y):m_i(i),m_y(y)  
8.     {  
9.     };  
10.     void StartThread();  
11.     m_y;  
12. protected:  
13.     int m_i;  
14. };  
15.   
16. void CThread::StartThread()  
17. {  
18.    AfxBeginThread(ThreadFunc,this);  
19. }  
20.   
21. unsigned ThreadFunc(void* lparam)//全局函数  
22. {  
23.    CThread* pthr = (CThread*)lparam;  
24.     for(int i = 0;i<10;i++)  
25.    {  
26.        std::cout<<i+pthr->m_i<<std::endl;//访问公有有成员  
27.       //std::cout<<i+pthr->m_y<<std::endl;//不能访问私有成员  
28.        Sleep(100);  
29.    }  
30.    return 0;  
31. };  
32.   
33. int main(int argc, char * argv[])  
34. {  
35.    CThread thread(1,2);  
36.    thread.StartThread();  
37.    return 0;  
38. }  

 

二、友元函数作为线程的入口函数：它的调用和传递机制跟C的全局函数是一样的。

[cpp]  view plain copy

1. class CThread  
2. {  
3. public:  
4.     CThread(int i,int y):m_i(i),m_y(y)  
5.     {  
6.     };  
7.     void StartThread();  
8.     friend unsigned ThreadFunc(void* lparam);  
9.     m_y;  
10. protected:  
11.     int m_i;  
12. };  
13.   
14. void CThread::StartThread()  
15. {  
16.    AfxBeginThread(ThreadFunc,this);  
17. }  
18.   
19. unsigned ThreadFunc(void* lparam)  
20. {  
21.    CThread* pthr = (CThread*)lparam;  
22.     for(int i = 0;i<10;i++)  
23.    {  
24.        std::cout<<i+pthr->m_i<<std::endl;  
25.        std::cout<<i+pthr->m_y<<std::endl;//访问私有成员  
26.        Sleep(100);  
27.    }  
28.    return 0;  
29. };  
30.   
31. int main(int argc, char * argv[])  
32. {  
33.    CThread thread(1,2);  
34.    thread.StartThread();  
35.    return 0;  
36. }  

友元函数比全局函数更加高效而强悍（能访问类的所有成员），但是以破坏类的封装性为代价的。

 

三、静态成员函数作为线程的成员函数：它对外可以是public也可以是private，它的优点就是没有破坏类的封装性。但它只能访问类的静态成员，当然这点可以通过给它的参数传递对象的this指针来克服，但这样也不能访问对象的public以外的成员。

[cpp]  view plain copy

1. class CThread  
2. {  
3. public:  
4.     CThread(int i,int y):m_i(i),m_y(y)  
5.     {  
6.     };  
7.     void StartThread();  
8.     static unsigned ThreadFunc(void* lparam);  
9.     m_y;  
10. protected:  
11.     int m_i;  
12. };  
13.   
14. void CThread::StartThread()  
15. {  
16.    AfxBeginThread(ThreadFunc,this);  
17. }  
18.   
19. unsigned CThread::ThreadFunc(void* lparam)  
20. {  
21.    CThread* pthr = (CThread*)lparam;  
22.     for(int i = 0;i<10;i++)  
23.    {  
24.        std::cout<<i+pthr->m_i<<std::endl;  
25.      //std::cout<<i+pthr->m_y<<std::endl;//不能访问私有成员  
26.        Sleep(100);  
27.    }  
28.    return 0;  
29. };  
30.   
31. int main(int argc, char * argv[])  
32. {  
33.    CThread thread(1,2);  
34.    thread.StartThread();  
35.    return 0;  
36. }  

 

四、普通成员函数作为线程入口函数：这种方式能突破上述方法的局限，即不破坏类的封装性，能访问对象的所以成员，可以是虚函数，能实现多态

class CThread

{
public:
    DWORD WINAPI ThreadFunc(LPVOID param);
    ...
};
有如上类，在类中某函数想以函数ThreadFunc最为线程入口函数：

CreateThread(NULL, 0, WorkThread, &param, 0, &ThreadID))

编译会报错：cannot convert parameter 3 from unsigned long (void *) to unsigned long (__stdcall *)(void *)        None of the functions with this name in scope match the target type

怎么解决这个问题，详解：http://blog.youkuaiyun.com/aguiwang/article/details/6941596