【Windows核心编程学习笔记】用户模式下的线程同步之二---关键段（critical section）

关键段是一小段代码，它在执行之前需要独占对一些共享资源的访问权。这种方式可以让多行代码以“原子方式”（指的是除了当前线程之外，没有其他任何线程会同时访问该资源）来对资源进行操控。当然，系统仍然可以暂停当前线程去调度其他线程。但是，在当前线程离开关键段之前，系统不会调度任何想要访问统一资源的其他线程的。

首先看一段代码：

[cpp]  view plain copy print ?

1. DWORD WINAPI FirstThread(PVOID pvParam)  
2. {   
3.     g_nSum = 0;  
4.     for(int i = 0;i<1000;++i)  
5.     {  
6.         g_nSum = 0;  
7.         for(int n=1; n<=Count; ++n)  
8.         {  
9.             g_nSum += n;  
10.         }  
11.     }  
12.     cout<<"First:"<<g_nSum<<endl;  
13.     return 0;  
14. }  
15.   
16. DWORD WINAPI SecondThread(PVOID pvParam)  
17. {  
18.     g_nSum = 0;  
19.     for(int i = 0;i<1000;++i)  
20.     {  
21.         g_nSum = 0;  
22.         for(int n=1; n<=Count; ++n)  
23.         {  
24.             g_nSum += n;  
25.         }  
26.     }  
27.   
28.     cout<<"Second:"<<g_nSum<<endl;  
29.     return 0;  
30. }  

上述代码，两个线程要访问统一共享变量，因此如果两个线程在统一时刻执行，那么每个线程都等于是在另一个线程背后修改共享变量的值，从而导致不可预料的结果。

我们可以用关键段来修改上述代码：

[cpp]  view plain copy print ?

1. #include <windows.h>  
2. #include <iostream>  
3. using namespace std;  
4.   
5. DWORD WINAPI FirstThread(PVOID pvParam);  
6. DWORD WINAPI SecondThread(PVOID pvParam);  
7. const long Count = 10000;  
8. long  g_nSum = 0;  
9. CRITICAL_SECTION g_cs; //定义关键段结构  
10.   
11. int main()  
12. {  
13.     if(InitializeCriticalSectionAndSpinCount(&g_cs,4000) != TRUE) //初始化关键段结构，同时使用旋转锁。  
14.     {  
15.         cout<<"初始化失败"<<endl;  
16.         return 1;  
17.     }  
18.     HANDLE hThread1 = CreateThread(NULL,0,FirstThread,NULL,0,0);  
19.     HANDLE hThread2 = CreateThread(NULL,0,SecondThread,NULL,0,0);  
20.     CloseHandle(hThread1);  
21.     CloseHandle(hThread2);  
22.     Sleep(5000);  
23.     DeleteCriticalSection(&g_cs); //释放关键段  
24.   
25.     return 0;  
26. }  
27.   
28. DWORD WINAPI FirstThread(PVOID pvParam)  
29. {  
30.     //需要使用共享资源的代码，放在EnterCriticalSection(&g_cs)和LeaveCriticalSection(&g_cs)之间  
31.     EnterCriticalSection(&g_cs);    
32.     g_nSum = 0;  
33.     for(int i = 0;i<1000;++i)  
34.     {  
35.         g_nSum = 0;  
36.         for(int n=1; n<=Count; ++n)  
37.         {  
38.             g_nSum += n;  
39.         }  
40.     }  
41.     LeaveCriticalSection(&g_cs);  
42.     cout<<"First:"<<g_nSum<<endl;  
43.     return 0;  
44. }  
45.   
46. DWORD WINAPI SecondThread(PVOID pvParam)  
47. {  
48.     EnterCriticalSection(&g_cs);  
49.     g_nSum = 0;  
50.     for(int i = 0;i<1000;++i)  
51.     {  
52.         g_nSum = 0;  
53.         for(int n=1; n<=Count; ++n)  
54.         {  
55.             g_nSum += n;  
56.         }  
57.     }  
58.     LeaveCriticalSection(&g_cs);  
59.     cout<<"Second:"<<g_nSum<<endl;  
60.     return 0;  
61. }  

运行结果：

我们首先定义了一个名为g_cs的CRITICAL_SECTION数据结构然后把需要访问共享资源的代码放在EnterCriticalSection（）和LeaveCriticalSection（）函数之间。注意，在调用这两个函数的时候传入的是变量g_cs的地址。

需要注意的地方有：当我们有一个资源，或者多个总是在一起使用的资源，那么我们可以创建一个CRITICAL_SECTION结构来保护这些资源。如果有多个不总是在一起使用的资源，那么应该创建多个CRITICAL_SECTION结构。

关键段的优点是：容易使用，它们内部其实是用interlocked函数实现的，因此执行速度很快。但是无法用来在多个进程之间对线程进行同步。

一般情况下，我们会将CRITICAL_SECTION结构作为全局变量来分配，这样进程中的所有线程就能够非常方便的通过变量名来方访问这些结构。但是，CRITICAL_SECTION结构也可以作为局部变量来分配，或者从堆中动态分配，另外将他们作为类的一个私有字段来分配也是很常见的。在使用CRITICAL_SECTION结构的时候，只有两个必要条件：

（1）所有要访问资源的线程必须知道用来保护资源的CRITICAL_SECTION结构的地址。

（2）任何线程在试图访问被保护的资源之前，必须对CRITICAL_SECTION结构的内部成员进行初始化。进行初始化的函数是：

[cpp]  view plain copy print ?

1. void WINAPI InitializeCriticalSection(  
2.   _Out_  LPCRITICAL_SECTION lpCriticalSection  
3. );  

这个函数对参数所指向的CRITICAL_SECTION结构的成员进行初始化。在调用EnterCriticalSection之前必须调用这个函数。

在对共享资源进行访问之前，需要调用下面函数，它会检查CRITICAL_SECTION结构中的成员变量，这些变量表示是否有线程正在访问资源，以及哪个线程正在访问资源：

[cpp]  view plain copy print ?

1. WINBASEAPI  
2. 　　VOID  
3. 　　WINAPI  
4. 　　EnterCriticalSection(  
5. 　　__inout LPCRITICAL_SECTION lpCriticalSection  
6. 　　);  

它会执行下列测试：

（1）如果没有线程正在访问资源，那么EnterCriticalSection会更新成员变量，以表示调用线程已经获准对资源的访问，并立即返回，这样线程就可以继续执行。
（2）如果成员变量表示调用线程已经获准访问资源，那么EnterCriticalSection会更新变量，以表示调用线程被获准访问的次数。
（3）如果成员变量表示其他线程已经获准访问资源，那么EnterCriticalSection会使用一个事件内核对象把当前线程切换到等待状态。这样线程不会像前一篇讲的旋转锁(spinlock)那样耗费CPU。系统会记住哪个线程想要访问这个资源，一旦当前正在访问资源的线程调用了LeaveCriticalSection，系统会自动更新CRITICAL_SECTION结构的成员变量并将等待中的线程切换回可调度状态。

注意，EnterCriticalSection函数是以原子方式执行这些测试。

另外一个可以执行和EnterCriticalSection函数相同功能的函数是：

[cpp]  view plain copy print ?

1. BOOL WINAPI TryEnterCriticalSection(  
2.   _Inout_  LPCRITICAL_SECTION lpCriticalSection  
3. );  

这个函数从来不会让调用线程进入等待状态。它会通过返回值来表示调用线程是否获得访问资源。如果发现资源正在被其他线程访问，就返回FASLE，否则返回TRUE。

通过这个函数线程可以快速地检查是否能够访问某个共享资源。如果不能访问，那么它可以继续做些其他的事情，而不用等待。如果返回TRUE，那么CRITICAL_SECTION结构的成员变量已经更新过了，以表示该线程正在访问资源。因此每个返回值为TRUE的调用必须有一个对应的LeaveCriticalSection。

在代码完成对共享资源的访问后，应该调用下列函数：

[cpp]  view plain copy print ?

1. void WINAPI LeaveCriticalSection(  
2.   _Inout_  LPCRITICAL_SECTION lpCriticalSection  
3. );  

它会检查结构内部的成员变量并将计数器减1，该计数器用来表示调用线程获准访问共享资源的次数。如果大于0，会直接返回，不会执行任何其他操作。如果计数器变为0，它会更新成员变量，以表示没有任何线程正在访问共享资源。

它同时会检查有没有其他线程由于调用了EnterCriticalSection函数而处于等待状态，如果有，那么函数会更新成员变量，把其中一个等待状态的线程切换回可调度状态。同样，它也是以原子方式执行所有操作。

如果线程不再需要访问共享资源的时候，可调用下列函数清理CRITICAL_SECTION结构：

[cpp]  view plain copy print ?

1. VOID DeleteCriticalSection (  
2.    LPCRITICAL_SECTION lpCriticalSection   // critical section  
3. );  

关键段和旋转锁结合

当线程试图进入一个关键段，但是这个关键段正被另一个线程占用的时候，函数会立即把调用线程切换到等待状态。这意味着线程必须从用户模式切换到内核模式（大约1000个CPU周期），这个切换的开销很大。

为了提高关键段的性能，Microsoft把旋转锁合并到了关键段中。因此，当调用EnterCriticalSection的时候，它会用一个旋转锁不断地循环，尝试在一段时间内获得对资源的访问。只有当尝试失败的时候，线程才会切换到内核模式并进入等待状态。

为了在使用关键段的时候同时使用旋转锁，必须调用下面的函数来初始化关键段：

[cpp]  view plain copy print ?

1. BOOL WINAPI InitializeCriticalSectionAndSpinCount(  
2.   _Out_  LPCRITICAL_SECTION lpCriticalSection,  
3.   _In_   DWORD dwSpinCount  
4. );  

第一个参数是关键段的地址，第二个参数是希望旋转锁循环的次数。如果我们在单处理器

上调用这个函数，那么函数会忽略这个参数，因此次数总是0.因为在单处理器上的机器上设置循环次数毫无意义：如果一个线程正在循环，那么占用资源的线程将没有机会放弃对资源的访问权。

代码示例：

[cpp]  view plain copy print ?

1. //关键段测试代码  
2.   
3. #include <iostream>  
4. #include <windows.h>  
5.   
6. using namespace std;  
7.   
8. CRITICAL_SECTION g_cs;//创建CRITICAL_SECTION结构全局变量  
9.   
10. int g_x = 20;  
11.   
12. //线程函数1  
13. DWORD WINAPI ThreadFunc1(LPVOID lpParam)  
14. {  
15.     while(TRUE)  
16.     {  
17.         EnterCriticalSection(&g_cs);  
18.         cout << "Thread1 get the access to resource" << endl;  
19.         if(g_x > 10)  
20.         {  
21.            Sleep(1);  
22.            cout<<"thread1 sell ticket : "<<g_x--<<endl;  
23.         }  
24.         else  
25.         {  
26.             cout << "Thread1 release the access to resource" << endl;  
27.             LeaveCriticalSection(&g_cs);  
28.             break;  
29.         }  
30.         cout << "Thread1 release the access to resource" << endl;  
31.         LeaveCriticalSection(&g_cs);  
32.     }  
33.   
34.     return 0;  
35. }  
36.   
37. //线程函数2  
38. DWORD WINAPI ThreadFunc2(LPVOID lpParameter)  
39. {  
40.     while(TRUE)  
41.     {  
42.         EnterCriticalSection(&g_cs);  
43.         cout << "Thread2 get the access to resource" << endl;  
44.         if(g_x > 0)  
45.         {  
46.            Sleep(1);  
47.            cout<<"thread2 sell ticket : "<<g_x--<<endl;  
48.         }  
49.         else  
50.         {  
51.             cout << "Thread2 release the access to resource" << endl;  
52.             LeaveCriticalSection(&g_cs);  
53.             break;  
54.         }  
55.         cout << "Thread2 release the access to resource" << endl;  
56.         LeaveCriticalSection(&g_cs);  
57.     }  
58.   
59.     return 0;  
60. }  
61.   
62. int main()  
63. {  
64.     HANDLE hThread1;  
65.     HANDLE hThread2;  
66.   
67.     if(InitializeCriticalSectionAndSpinCount(&g_cs,10000) != TRUE) //初始化关键段结构，同时使用旋转锁。  
68.     {  
69.         cout<<"初始化失败"<<endl;  
70.         return 1;  
71.     }  
72.   
73.     hThread1=CreateThread(NULL,0,ThreadFunc1,NULL,0,NULL);  
74.     hThread2=CreateThread(NULL,0,ThreadFunc2,NULL,0,NULL);  
75.   
76.     CloseHandle(hThread1);  
77.     CloseHandle(hThread2);  
78.   
79.     Sleep(4000);  
80.     DeleteCriticalSection(&g_cs);  
81.   
82.     return 0;  
83. }  

运行结果：

分享到： 

• 上一篇：【Windows核心编程学习笔记】用户模式下的线程同步之一---Interlocked系列函数及高速缓存行