临界区对象

使用InitializeCriticalSection初始化关键代码段
使用EnterCriticalSection进入关键代码段：
使用LeaveCriticalSection离开关键代码段：
使用DeleteCriticalSection删除关键代码段，释放资源
我们看一个例子：

[cpp]  view plain copy

1. #include <Windows.h>  
2. #include <stdio.h>  
3.   
4. //线程函数声明  
5. DWORD WINAPI Thread1Proc(  LPVOID lpParameter);  
6. DWORD WINAPI Thread2Proc(  LPVOID lpParameter);  
7.   
8. //全局变量  
9. int tickets = 100;  
10. CRITICAL_SECTION g_cs;  
11.   
12. int main()  
13. {  
14.     HANDLE hThread1;  
15.     HANDLE hThread2;  
16.     //初始化关键代码段  
17.     InitializeCriticalSection(&g_cs);  
18.     //创建线程1  
19.     hThread1 = CreateThread(NULL,       //默认安全级别  
20.                             0,          //默认栈大小  
21.                             Thread1Proc,//线程函数   
22.                             NULL,       //函数没有参数  
23.                             0,          //创建后直接运行  
24.                             NULL);      //线程标识，不需要  
25.   
26.     //创建线程2  
27.     hThread2 = CreateThread(NULL,       //默认安全级别  
28.                             0,          //默认栈大小  
29.                             Thread2Proc,//线程函数   
30.                             NULL,       //函数没有参数  
31.                             0,          //创建后直接运行  
32.                             NULL);      //线程标识，不需要  
33.   
34.   
35.     //主线程休眠4秒  
36.     Sleep(4000);  
37.     //关闭线程句柄  
38.     CloseHandle(hThread1);  
39.     CloseHandle(hThread2);  
40.     //关闭事件对象句柄  
41.     DeleteCriticalSection(&g_cs);  
42.     return 0;  
43. }  
44.   
45. //线程1入口函数  
46. DWORD WINAPI Thread1Proc(  LPVOID lpParameter)  
47. {  
48.     while(TRUE)  
49.     {  
50.         //进入关键代码段前调用该函数判断否能得到临界区的使用权  
51.         EnterCriticalSection(&g_cs);  
52.         Sleep(1);  
53.         if(tickets > 0)  
54.         {  
55.             Sleep(1);  
56.             printf("thread1 sell ticket : %d\n",tickets--);  
57.             //访问结束后释放临界区对象的使用权  
58.             LeaveCriticalSection(&g_cs);  
59.             Sleep(1);  
60.         }  
61.         else  
62.         {  
63.             LeaveCriticalSection(&g_cs);  
64.             break;  
65.         }  
66.     }  
67.   
68.     return 0;  
69. }  
70.   
71. //线程2入口函数  
72. DWORD WINAPI Thread2Proc(  LPVOID lpParameter)  
73. {  
74.     while(TRUE)  
75.     {  
76.         //进入关键代码段前调用该函数判断否能得到临界区的使用权  
77.         EnterCriticalSection(&g_cs);  
78.         Sleep(1);  
79.         if(tickets > 0)  
80.         {  
81.             Sleep(1);  
82.             printf("thread2 sell ticket : %d\n",tickets--);  
83.             //访问结束后释放临界区对象的使用权  
84.             LeaveCriticalSection(&g_cs);  
85.             Sleep(1);  
86.         }  
87.         else  
88.         {  
89.             LeaveCriticalSection(&g_cs);  
90.             break;  
91.         }  
92.     }  
93.   
94.     return 0;  
95. }  

在这个例子中，通过在放弃临界区资源后，立即睡眠引起另一个线程被调用，导致两个线程交替售票。
下面看一个多线程程序中常犯的一个错误-线程死锁。死锁产生的原因，举个例子：线程1拥有临界区资源A，正在等待临界区资源B；而线程2拥有临界区资源B，正在等待临界区资源A。它俩各不相让，结果谁也执行不了。我们看看程序：

[cpp]  view plain copy

1. #include <Windows.h>  
2. #include <stdio.h>  
3.   
4. //线程函数声明  
5. DWORD WINAPI Thread1Proc(  LPVOID lpParameter);  
6. DWORD WINAPI Thread2Proc(  LPVOID lpParameter);  
7.   
8. //全局变量  
9. int tickets = 100;  
10. CRITICAL_SECTION g_csA;  
11. CRITICAL_SECTION g_csB;  
12. int main()  
13. {  
14.     HANDLE hThread1;  
15.     HANDLE hThread2;  
16.     //初始化关键代码段  
17.     InitializeCriticalSection(&g_csA);  
18.     InitializeCriticalSection(&g_csB);  
19.     //创建线程1  
20.     hThread1 = CreateThread(NULL,       //默认安全级别  
21.                             0,          //默认栈大小  
22.                             Thread1Proc,//线程函数   
23.                             NULL,       //函数没有参数  
24.                             0,          //创建后直接运行  
25.                             NULL);      //线程标识，不需要  
26.   
27.     //创建线程2  
28.     hThread2 = CreateThread(NULL,       //默认安全级别  
29.                             0,          //默认栈大小  
30.                             Thread2Proc,//线程函数   
31.                             NULL,       //函数没有参数  
32.                             0,          //创建后直接运行  
33.                             NULL);      //线程标识，不需要  
34.     //关闭线程句柄  
35.     //当不再引用这个句柄时，立即将其关闭，减少其引用计数  
36.     CloseHandle(hThread1);  
37.     CloseHandle(hThread2);  
38.   
39.     //主线程休眠4秒  
40.     Sleep(4000);  
41.   
42.     //关闭事件对象句柄  
43.     DeleteCriticalSection(&g_csA);  
44.     DeleteCriticalSection(&g_csB);  
45.     return 0;  
46. }  
47.   
48. //线程1入口函数  
49. DWORD WINAPI Thread1Proc(  LPVOID lpParameter)  
50. {  
51.     while(TRUE)  
52.     {  
53.         EnterCriticalSection(&g_csA);  
54.         Sleep(1);  
55.         EnterCriticalSection(&g_csB);  
56.         if(tickets > 0)  
57.         {  
58.             Sleep(1);  
59.             printf("thread1 sell ticket : %d\n",tickets--);  
60.             LeaveCriticalSection(&g_csB);  
61.             LeaveCriticalSection(&g_csA);  
62.             Sleep(1);  
63.         }  
64.         else  
65.         {  
66.             LeaveCriticalSection(&g_csB);  
67.             LeaveCriticalSection(&g_csA);  
68.             break;  
69.         }  
70.     }  
71.   
72.     return 0;  
73. }  
74.   
75. //线程2入口函数  
76. DWORD WINAPI Thread2Proc(  LPVOID lpParameter)  
77. {  
78.     while(TRUE)  
79.     {  
80.         EnterCriticalSection(&g_csB);  
81.         Sleep(1);  
82.         EnterCriticalSection(&g_csA);  
83.         if(tickets > 0)  
84.         {  
85.             Sleep(1);  
86.             printf("thread2 sell ticket : %d\n",tickets--);  
87.             LeaveCriticalSection(&g_csA);  
88.             LeaveCriticalSection(&g_csB);  
89.             Sleep(1);  
90.         }  
91.         else  
92.         {  
93.             LeaveCriticalSection(&g_csA);  
94.             LeaveCriticalSection(&g_csB);  
95.             break;  
96.         }  
97.     }  
98.   
99.     return 0;  
100. }  

在程序中，创建了两个临界区对象g_csA和g_csB。线程1中先尝试获取g_csA，获取成功后休眠，线程2尝试获取g_csB，成功后休眠，切换回线程1，然后线程1试图获取g_csB，因为g_csB已经被线程2获取，所以它线程1的获取不会成功，一直等待，直到自己的时间片结束后，转到线程2，线程2获取g_csB后，试图获取g_csA，当然也不会成功，转回线程1……这样交替等待，直到主线程睡醒，执行完毕，程序结束。

线程锁的概念函数EnterCriticalSection和LeaveCriticalSection的用法

注：使用结构CRITICAL_SECTION 需加入头文件#include “afxmt.h”

定义一个全局的锁 CRITICAL_SECTION的实例
和一个静态全局变量

1. CRITICAL_SECTION cs;//可以理解为锁定一个资源
2. static int n_AddValue = 0;//定义一个静态的全部变量n_AddValue

创建两个线程函数，代码实现如下：

1. //第一个线程
2. UINT FirstThread(LPVOID lParam)
3. {
4.     EnterCriticalSection(&cs);//加锁 接下来的代码处理过程中不允许其他线程进行操作，除非遇到LeaveCriticalSection
5.     for(int i = 0; i<10; i++){       
6.         n_AddValue ++;
7.         cout << "n_AddValue in FirstThread is "<<n_AddValue <<endl;       
8.    
9.     }
10.     LeaveCriticalSection(&cs);//解锁 到EnterCriticalSection之间代码资源已经释放了，其他线程可以进行操作   
11.     return 0;
12.  
13. }
14.  
15. //第二个线程
16. UINT SecondThread(LPVOID lParam)
17. {
18.     EnterCriticalSection(&cs);//加锁
19.     for(int i = 0; i<10; i++){       
20.         n_AddValue ++;       
21.         cout << "n_AddValue in SecondThread is "<<n_AddValue <<endl;   
22.        
23.     }
24.     LeaveCriticalSection(&cs);//解锁
25.  
26.     return 0;
27.  
28. }

在主函数添加以下代码

1. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
2. {
3.     int nRetCode = 0;
4.  
5.     // 初始化 MFC 并在失败时显示错误
6.     if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))
7.     {
8.         // TODO: 更改错误代码以符合您的需要
9.         _tprintf(_T("错误: MFC 初始化失败/n"));
10.         nRetCode = 1;
11.     }
12.     else
13.     {
14.  
15.         InitializeCriticalSection(&cs);//初始化结构CRITICAL_SECTION
16.  
17.  
18.         CWinThread *pFirstThread,*pSecondThread;//存储函数AfxBeginThread返回的CWinThread指针
19.        
20.  
21.         pFirstThread  = AfxBeginThread(FirstThread,LPVOID(NULL));//启动第一个线程
22.         pSecondThread = AfxBeginThread(SecondThread,LPVOID(NULL));//启动第二个线程
23.  
24.         HANDLE hThreadHandle[2];//
25.         hThreadHandle[0] = pFirstThread->m_hThread;
26.         hThreadHandle[1] = pSecondThread->m_hThread;
27.  
28.         //等待线程返回
29.         WaitForMultipleObjects(2,hThreadHandle,TRUE,INFINITE);       
30.     }
31.  
32.     return nRetCode;
33. }

输出：

n_AddValue in FirstThread is 1
n_AddValue in FirstThread is 2
n_AddValue in FirstThread is 3
n_AddValue in FirstThread is 4
n_AddValue in FirstThread is 5
n_AddValue in FirstThread is 6
n_AddValue in FirstThread is 7
n_AddValue in FirstThread is 8
n_AddValue in FirstThread is 9
n_AddValue in FirstThread is 10
n_AddValue in SecondThread is 11
n_AddValue in SecondThread is 12
n_AddValue in SecondThread is 13
n_AddValue in SecondThread is 14
n_AddValue in SecondThread is 15
n_AddValue in SecondThread is 16
n_AddValue in SecondThread is 17
n_AddValue in SecondThread is 18
n_AddValue in SecondThread is 19
n_AddValue in SecondThread is 20

如果把两个线程函数中的EnterCriticalSection和LeaveCriticalSection位置移到for循环中去，线程的执行顺序将会改变
输出也就跟着改变，如：

1. //第一个线程
2. UINT FirstThread(LPVOID lParam)
3. {
4.    
5.     for(int i = 0; i<10; i++){
6.         EnterCriticalSection(&cs);//加锁 锁移到for循环内部里
7.         n_AddValue ++;
8.         cout << "n_AddValue in FirstThread is "<<n_AddValue <<endl;   
9.         LeaveCriticalSection(&cs);//解锁 
10.     }   
11.     return 0;
12. }
13.  
14. //第二个线程
15. UINT SecondThread(LPVOID lParam)
16. {
17.    
18.     for(int i = 0; i<10; i++){   
19.         EnterCriticalSection(&cs);//加锁
20.         n_AddValue ++;       
21.         cout << "n_AddValue in SecondThread is "<<n_AddValue <<endl;
22.         LeaveCriticalSection(&cs);//解锁       
23.     }
24.     return 0;
25. }

其他代码不变，输出的结果如下：

n_AddValue in FirstThread is 1
n_AddValue in SecondThread is 2
n_AddValue in FirstThread is 3
n_AddValue in SecondThread is 4
n_AddValue in FirstThread is 5
n_AddValue in SecondThread is 6
n_AddValue in FirstThread is 7
n_AddValue in SecondThread is 8
n_AddValue in FirstThread is 9
n_AddValue in SecondThread is 10
n_AddValue in FirstThread is 11
n_AddValue in SecondThread is 12
n_AddValue in FirstThread is 13
n_AddValue in SecondThread is 14
n_AddValue in FirstThread is 15
n_AddValue in SecondThread is 16
n_AddValue in FirstThread is 17
n_AddValue in SecondThread is 18
n_AddValue in FirstThread is 19
n_AddValue in SecondThread is 20

个人认为在函数EnterCriticalSection和LeaveCriticalSection中间的代码执行过程不会被其他线程干拢或者这么讲不允许其他线程中
的代码执行。这样可以有效防止一个全局变量在两个线程中同时被操作的可能性