CPP-基础：临界区

VC windows api 多线程---临界区

临界区（Critical Section）是一段独占对某些共享资源访问的代码，在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。

　　临界区在使用时以CRITICAL_SECTION结构对象保护共享资源，并分别用EnterCriticalSection（）和LeaveCriticalSection（）函数去标识和释放一个临界区。所用到的CRITICAL_SECTION结构对象必须经过InitializeCriticalSection（）的初始化后才能使用，而且必须确保所有线程中的任何试图访问此共享资源的代码都处在此临界区的保护之下。否则临界区将不会起到应有的作用，共享资源依然有被破坏的可能。

　　在所有的同步对象中，临界区是最容易使用的，但是，一个临界区对一个进程或DLL是有限的，不能被其他进程共享，只能用于同步单个进程中的线程。临界区不是Windows内核对象，它和内核对象不同，存在于进程的内存空间中。
Win32 API提供了几个临界区函数：
　　void InitializeCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
　　void EnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
　　void LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
　　void DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection);
CRITICAL_SECTION类型的变量用来扮演红绿灯的角色，让同一个时间内只有一个线程进入临界区。该临界区变量的声明必须是全局的，这样不同的线程就能访问它。操纵临界区的Win32函数初始化和维护该结构中的所有成员，不要自己去访问和修改任何成员。
使用临界区之前，必须调用InitializeCriticalSection()函数来初始化临界区。而通过调用EnterCriticalSection()函数来取得一个临界区的所有权。然后通过LeaveCriticalSection()函数来释放所有权。临界区通过一个线程取得所有权来显示它已经进入代码临界区的方法进行工作，如果其他线程调用EnterCriticalSection()并引用同一临界区，它会被阻塞，直到第一个线程调用LeaveCriticalSection()函数。最后，可以调用DeleteCriticalSection()函数来释放用户初始化临界区时分配的系统资源。

下面例1，例2用来帮助理解：

例1：

 1 #include "stdafx.h"
 2 #include <stdio.h>
 3 #include <windows.h>
 4 #include <string.h>
 5 #include <stdlib.h>
 6 #define threadnum 10
 7 typedef struct THREADDATA
 8 {
 9 int id;
10 char name[10];
11 int sleep;
12 }THREADDATA;
13 CRITICAL_SECTION sec1;
14 char * str;
15 DWORD WINAPI ThreadProc( LPVOID lpParam )
16 {
17     THREADDATA *data=(THREADDATA *)lpParam;
18     printf("%d\n%s\n",data->id,data->name);
19     EnterCriticalSection(&sec1);
20     for(int i=0;i<10;i++)
21     {
22     // EnterCriticalSection(&sec1);
23     printf("thread%d:%d\n",data->id,i);
24     // LeaveCriticalSection(&sec1);
25     Sleep(data->sleep);
26     }
27     LeaveCriticalSection(&sec1);
28     return 0;
29 }
30 int main(int argc, char* argv[])
31 {
32     str=(char*)malloc(30);
33     THREADDATA pData[threadnum];
34     DWORD dwThreadId[threadnum];
35     HANDLE hThread[threadnum];
36     InitializeCriticalSection(&sec1);
37 
38     for(int i=0;i<threadnum;i++)
39     {
40         pData[i].id=i;
41         sprintf(pData[i].name,"yuguoqing");
42         pData[i].sleep=i*10;
43         hThread[i] = CreateThread(NULL,0,ThreadProc, pData+i, 0, dwThreadId+i);
44     }
45     WaitForMultipleObjects(threadnum, hThread, TRUE, INFINITE);
46     return 0;
47 }

 

例2：

图1 使用临界区保持线程同步

　　下面通过一段代码展示了临界区在保护多线程访问的共享资源中的作用。通过两个线程来分别对全局变量g_cArray[10]进行写入操作，用临界区结构对象g_cs来保持线程的同步，并在开启线程前对其进行初始化。为了使实验效果更加明显，体现出临界区的作用，在线程函数对共享资源g_cArray[10]的写入时，以Sleep（）函数延迟1毫秒，使其他线程同其抢占CPU的可能性增大。如果不使用临界区对其进行保护，则共享资源数据将被破坏（参见图1（a）所示计算结果），而使用临界区对线程保持同步后则可以得到正确的结果（参见图1（b）所示计算结果）。代码实现清单附下：

 1 // 临界区结构对象
 2 CRITICAL_SECTION g_cs;
 3 // 共享资源 
 4 char g_cArray[10];
 5 UINT ThreadProc10(LPVOID pParam)
 6 {
 7 　// 进入临界区
 8 　EnterCriticalSection(&g_cs);
 9 　// 对共享资源进行写入操作
10 　for (int i = 0; i < 10; i++)
11 　{
12 　　g_cArray[i] = 'a';
13 　　Sleep(1);
14 　}
15 　// 离开临界区
16 　LeaveCriticalSection(&g_cs);
17 　return 0;
18 }
19 UINT ThreadProc11(LPVOID pParam)
20 {
21 　// 进入临界区
22 　EnterCriticalSection(&g_cs);
23 　// 对共享资源进行写入操作
24 　for (int i = 0; i < 10; i++)
25 　{
26 　　g_cArray[10 - i - 1] = 'b';
27 　　Sleep(1);
28 　}
29 　// 离开临界区
30 　LeaveCriticalSection(&g_cs);
31 　return 0;
32 }
33 ……
34 void CSample08View::OnCriticalSection() 
35 {
36 　// 初始化临界区
37 　InitializeCriticalSection(&g_cs);
38 　// 启动线程
39 　AfxBeginThread(ThreadProc10, NULL);
40 　AfxBeginThread(ThreadProc11, NULL);
41 　// 等待计算完毕
42 　Sleep(300);
43 　// 报告计算结果
44 　CString sResult = CString(g_cArray);
45 　AfxMessageBox(sResult);
46 }

 

 

MFC临界区

　　在MFC中封装了CCriticalSection类作为临界区对象，在构造函数中自动调用InitialCriticalSection()函数，在析构函数中自动调用LeaveCriticalSection()函数，用Lock()和Unlock()对应取得所有权和释放所有权。

 1 // MFC临界区类对象
 2 CCriticalSection g_clsCriticalSection;
 3 // 共享资源 
 4 char g_cArray[10];
 5 UINT ThreadProc20(LPVOID pParam)
 6 {
 7 　// 进入临界区
 8 　g_clsCriticalSection.Lock();
 9 　// 对共享资源进行写入操作
10 　for (int i = 0; i < 10; i++)
11 　{
12 　　g_cArray[i] = 'a';
13 　　Sleep(1);
14 　}
15 　// 离开临界区
16 　g_clsCriticalSection.Unlock();
17 　return 0;
18 }
19 UINT ThreadProc21(LPVOID pParam)
20 {
21 　// 进入临界区
22 　g_clsCriticalSection.Lock();
23 　// 对共享资源进行写入操作
24 　for (int i = 0; i < 10; i++)
25 　{
26 　　g_cArray[10 - i - 1] = 'b';
27 　　Sleep(1);
28 　}
29 　// 离开临界区
30 　g_clsCriticalSection.Unlock();
31 　return 0;
32 }
33 ……
34 void CSample08View::OnCriticalSectionMfc() 
35 {
36 　// 启动线程
37 　AfxBeginThread(ThreadProc20, NULL);
38 　AfxBeginThread(ThreadProc21, NULL);
39 　// 等待计算完毕
40 　Sleep(300);
41 　// 报告计算结果
42 　CString sResult = CString(g_cArray);
43 　AfxMessageBox(sResult);
44 }