临界区

#include "windows.h"

CRITICAL_SECTION  _critical

/*初始化，最先调用的函数。没什么好说的，一般windows编程都有类似初始化的方法*/

InitializeCriticalSection(& _critical) 

/*释放资源，确定不使用_critical时调用，一般在程序退出的时候调用。如果以后还要用_critical，则要重新调用InitializeCriticalSection

*/

DeleteCriticalSection(& _critical) 

/*

把代码保护起来。调用此函数后，他以后的资源其他线程就不能访问了。

*/

EnterCriticalSection（& _critical）

/*

离开临界区，表示其他线程能够进来了。注意EnterCritical和LeaveCrticalSection必须是成对出现的!当然除非你是想故意死锁！

*/

LeaveCriticalSection(& _critical)

在使用多线程时，一般很少有多个线程完全独立的工作。往往是多个线程同时操作一个全局变量来获取程序的运行结果。多个线程同时访问同一个全局变量， 如果都是读取操作，则不会出现问题。如果是写操作，则会发生错误。这时候，我们可以通过临界区，为全局变量设置一个保护，保证同时只有一个线程可以访问此 变量，其他变量进入等待状态。
      临界区（Critical Section）是一段独占对某些共享资源访问的代码，在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线 程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操 作共享资源的目的。

#include "stdafx.h"
#include<process.h>
#include<iostream>
#include<windows.h>


CRITICAL_SECTION g_cs;
const int g_Number = 2;
DWORD WINAPI ThreadProc1(LPVOID lpParam);
DWORD WINAPI ThreadProc2(LPVOID lpParam);
int g_value = 0;


int _tmain(int argc, _TCHAR* argv[])
{
    InitializeCriticalSection(&g_cs);
    HANDLE hThread[g_Number] = {0};
    int first = 1, second = 2;
    hThread[0] = (HANDLE)_beginthreadex(NULL,0,(unsigned int(_stdcall*)(void*))&ThreadProc1,(LPVOID)first,0,NULL);
    hThread[1] = (HANDLE)_beginthreadex(NULL, 0, (unsigned int(_stdcall*)(void*))&ThreadProc2, (LPVOID)second, 0, NULL);
    WaitForMultipleObjects(g_Number,hThread,TRUE,INFINITE);
    CloseHandle(hThread[0]);
    CloseHandle(hThread[1]);
    DeleteCriticalSection(&g_cs);
return 0;
}
DWORD WINAPI ThreadProc1(LPVOID lpParam)
{
    EnterCriticalSection(&g_cs);
    for (int i = 0; i < 10; i++)
    {
            std::cout << "线程1："<<g_value++ << std::endl;
    }
    LeaveCriticalSection(&g_cs);
    return 0;
}
DWORD WINAPI ThreadProc2(LPVOID lpParam)
{
    EnterCriticalSection(&g_cs);
    for (int i = 0; i < 10; i++)
    {
            std::cout << "线程2：" << g_value++ << std::endl;
    }
    LeaveCriticalSection(&g_cs);
    return 0;
}

每次对共享数据进行操作时，都需要对数据进行EnterCriticalSection和LeaveCriticalSection的操作。但是，这中间也不是一帆风顺的。很有可能你会遇到各种各样的错误。那么，这时候你的程序就需要跳出去了。可能一开始遇到error的时候，你还记得需要退出临界区。但是，如果错误多了，你未必记得还有这个操作了。这一错就完了，别的线程就没有机会获取这个锁了。

1. class CLock  
2. {  
3.     CRITICAL_SECTION& cs;  
4.   
5. public:  
6.     CLock(CRITICAL_SECTION& lock):cs(lock){  
7.         EnterCriticalSection(&cs);  
8.     }  
9.   
10.     ~CLock() {  
11.         LeaveCriticalSection(&cs);  
12.     }  
13. } 

C++的一个重要特点就是，不管函数什么时候退出，系统都会自动调用类的析构函数。临界区只对多线程有效，同一线程可重复进入。

使用过程中，要注意：假定下面这个函数的进程中的另一个线程也要访问这两个数组：

DWORD WINAPI OtherThreadFunc(PVOID pvParam)

{

EnterCriticalSection(&g_csChars);

EnterCriticalSection(&g_csNums);

for(int x=0;x<100;x++)

{

g_nNums[x]=g_cChars[x];

}

LeaveCriticalSection(&g_csNums);

LeaveCriticalSection(&g_csChars);

return 0;

}

在上面这个函数中只是切换对EnterCriticalSection(&g_csChars);和EnterCriticalSection(&g_csNums);函数的调用顺序，可能导致死锁状态。假定一个函数先获得g_csNums的

所有权，另一个函数获得g_csChars的所有权，就会产生死锁。为了解决这个问题，必须按照完全相同的顺序请求对资源的访问。