多线程同步之Critical Sections（功能与Mutex相同，保证某一时刻只有一个线程能够访问共享资源，但是不是内核对象，所以访问速度要比Mutex快，但是增没有等待超时的功能，所以有可能会导致死锁，使用时可以根据实际的情况选择其一）
一 Critical Sections
1） 因为Critical Sections不是内核对象，所以只能用来统一进程内线程间的同步，不能用来多个不同进程间的线程的同步。
2） 如果在Critical Sections中间突然程序crash或是exit而没有调用LeaveCriticalSection，则结果是改线程所对应的内核不能被释放，该线程成为死线程。
3） 要比其他的内核对象的速度要快。
二 使用CriticalSections的简单实例，Stack在push的时候可以分为3个步骤，看下面的代码，但是如果在第2步后此线程中断切换到其他的线程，其他的线程push后再返回执行时，此线程继续执行，这样有可能刚才其他线程push就会被覆盖了，在stack里找不到了。（下面的代码在debug下使用了CriticalSection，release下可能有问题）
#include <windows.h>
#include <process.h>
#include <stdio.h>
/**////////////////////////////////////////////////stack:
struct Node
{
struct Node *next;
int data;
};
struct Stack
{
struct Node *head;
#ifdef _DEBUG
CRITICAL_SECTION critical_sec;
#endif
Stack()
{
head = NULL;
#ifdef _DEBUG
InitializeCriticalSection(&critical_sec);
#endif
}
~Stack()
{
if(head != NULL)
{
if(NULL == head->next)
{
delete head;
head = NULL;
}
else
{
Node *p = head;
Node *q = head->next;
while(q != NULL)
{
delete p;
p = q;
q = q->next;
};
delete p;
p = NULL;
}
}
#ifdef _DEBUG
DeleteCriticalSection(&critical_sec);
#endif
}
void Push (int num)
{
//enter critical section, add a new node and then
#ifdef _DEBUG
EnterCriticalSection (&critical_sec);
#endif
Node * node = new Node();
node->next = head;
node->data = num;
head = node;
printf("Stack:%d\n",num);
//leave critical section
#ifdef _DEBUG
LeaveCriticalSection (&critical_sec);
#endif
}
int Pop ()
{
#ifdef _DEBUG
EnterCriticalSection (&critical_sec);
#endif
int result = 0;
if(head!= NULL)
{
result = head->data;
if(head->next != NULL)
{
Node *temp = head->next;
delete head;
head = temp;
}
else
head = NULL;
}
#ifdef _DEBUG
LeaveCriticalSection (&critical_sec);
#endif
return result;
}
};
/**/////////////////////////////////////////////////////////test:
unsigned __stdcall Thread1(void * pVoid)
{
Stack *stack = ((Stack*)pVoid);
for(int i = 200; i<220;++i)
{
stack->Push(i);
}
return 1;
}
unsigned __stdcall Thread2(void *pVoid)
{
Stack *stack = ((Stack*)pVoid);
for(int i = 0; i<20; ++i)
{
stack->Push(i);
}
return 1;
}
int main()
{
Stack stack;
stack.Push(1000);
stack.Push(1000);
HANDLE hth1;
unsigned uiThread1ID;
hth1 = (HANDLE)_beginthreadex( NULL, // security
0, // stack size
Thread1,
(void*)&stack, // arg list
CREATE_SUSPENDED, // so we can later call ResumeThread()
&uiThread1ID );
if ( hth1 == 0 )
printf("Failed to create thread 1\n");
DWORD dwExitCode;
GetExitCodeThread( hth1, &dwExitCode ); // should be STILL_ACTIVE = 0x00000103 = 259
printf( "initial thread 1 exit code = %u\n", dwExitCode );
HANDLE hth2;
unsigned uiThread2ID;
hth2 = (HANDLE)_beginthreadex( NULL, // security
0, // stack size
Thread2,
(void*)&stack, // arg list
CREATE_SUSPENDED, // so we can later call ResumeThread()
&uiThread2ID );
if ( hth2 == 0 )
printf("Failed to create thread 2\n");
GetExitCodeThread( hth2, &dwExitCode ); // should be STILL_ACTIVE = 0x00000103 = 259
printf( "initial thread 2 exit code = %u\n", dwExitCode );
ResumeThread( hth1 );
ResumeThread( hth2 );
WaitForSingleObject( hth1, INFINITE );
WaitForSingleObject( hth2, INFINITE );
GetExitCodeThread( hth1, &dwExitCode );
printf( "thread 1 exited with code %u\n", dwExitCode );
GetExitCodeThread( hth2, &dwExitCode );
printf( "thread 2 exited with code %u\n", dwExitCode );
CloseHandle( hth1 );
CloseHandle( hth2 );
printf("Primary thread terminating.\n");
}三 对Critical Section的封装：
//////////////////////////////////////////////////////
// 方法一： Lock中的CritSect成员变量必须是引用类型。
class CritSect
{
public:
friend class Lock;
CritSect() { InitializeCriticalSection(&_critSection); }
~CritSect() { DeleteCriticalSection(&_critSection); }
private:
void Acquire(){EnterCriticalSection(&_critSection);}
void Release(){LeaveCriticalSection(&_critSection);}
CRITICAL_SECTION _critSection;
};
class Lock
{
public:
Lock(CritSect& critSect):_critSect(critSect) { _critSect.Acquire(); }
~Lock(){_critSect.Release();}
private:
CritSect& _critSect;
};
//////////////////////////////////////////////////////
//方法二：
// MT-exclusive lock
class CLock {
public:
CLock() { InitializeCriticalSection (&m_criticalSection); }
void Lock () { EnterCriticalSection (&m_criticalSection); }
void Unlock () { LeaveCriticalSection (&m_criticalSection); }
virtual ~CLock() { DeleteCriticalSection (&m_criticalSection); }
private:
CRITICAL_SECTION m_criticalSection;
};
// Scoped MT-exclusive lock
class CScopedLocker {
public:
CScopedLocker (CLock * t) : m_lock (t) { m_lock->Lock(); }
~CScopedLocker() { m_lock->Unlock(); }
private:
CLock * m_lock;
};
对上面的2中封装的调用都比较简单，都是只有2行代码。
CritSect sect;
Lock lock(sect);
或
CLock t；
CSCopedLocker st(&t);
下面的对封装的测试代码，保证了对g_n全局变量在线程1操作结束后线程2才可以操作。（下面的代码因为对全局变量同步，所以需要申明含有CRITICAL_SECTION的类为全局）
#include<windows.h>
#include<iostream>
using namespace std;
/**///////////////////////////////////////////////////////// ·½·¨Ò»£º
class CritSect
{
public:
friend class Lock;
CritSect() { InitializeCriticalSection(&_critSection); }
~CritSect() { DeleteCriticalSection(&_critSection); }
private:
void Acquire(){EnterCriticalSection(&_critSection);}
void Release(){LeaveCriticalSection(&_critSection);}
CRITICAL_SECTION _critSection;
};
class Lock
{
public:
Lock(CritSect& critSect):_critSect(critSect) { _critSect.Acquire(); }
~Lock(){_critSect.Release();}
private:
CritSect& _critSect;
};
/**/////////////////////////////////////////////////////////·½·¨¶þ£º
// MT-exclusive lock
class CLock {
public:
CLock() { InitializeCriticalSection (&m_criticalSection); }
void Lock () { EnterCriticalSection (&m_criticalSection); }
void Unlock () { LeaveCriticalSection (&m_criticalSection); }
virtual ~CLock() { DeleteCriticalSection (&m_criticalSection); }
private:
CRITICAL_SECTION m_criticalSection;
};
// Scoped MT-exclusive lock
class CScopedLocker {
public:
CScopedLocker (CLock * t) : m_lock (t) { m_lock->Lock(); }
~CScopedLocker() { m_lock->Unlock(); }
private:
CLock * m_lock;
};
// ¶ÔÈ«¾ÖµÄ±äÁ¿£¬Ê¹ÓÃCritical Section
// Declare the global variable
static int g_n;
CritSect sect;
//CLock t;
/**/////////Thread One Function///////////////////UINT ThreadOne(LPVOID lParam)
{
Lock lock(sect);
//CScopedLocker st(&t);
for(int i=0;i<100;i++)
{
g_n++;
cout << "Thread 1: " << g_n << "\n";
}
// return the thread
return 0;
}
/**/////////Thread Two Function///////////////////UINT ThreadTwo(LPVOID lParam)
{
Lock lock(sect);
//CScopedLocker st(&t);
for(int i=300;i<400;i++)
{
g_n++;
cout << "Thread 2: "<< g_n << "\n";
}
// return the thread
return 0;
}
int main()
{
// Create the array of Handle
HANDLE hThrd[2];
//Thread ID's
DWORD IDThread1, IDThread2;
// Create thredas use CreateThread function with NULL Security
hThrd[0] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) ThreadOne,(LPVOID)NULL,0,&IDThread1);
hThrd[1] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) ThreadTwo,(LPVOID)NULL,0,&IDThread2);
// Wait for the main thread
WaitForMultipleObjects(2,hThrd,TRUE,INFINITE);
return 0;
}
四 API列表：