线程同步的四种方法

一、基于CRITICAL_SECTION的同步

基于CRITICAL_SECTION的同步中将创建并运用“CRITICAL_SECTION对象”，但这并非内核对象。与其他同步对象相同，它是进入临界区的一把“钥匙”。离开时需要上交CRITICAL_SECTION对象。

#include 
//初始化函数原型
VOID InitializeCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection   // address of critical 
                                         // section object
);

//销毁函数原型
VOID DeleteCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection   // pointer to critical 
                                         // section object
);

其中lpCriticalSection，在初始化函数中传入需要初始化的CRITICAL_SECTION对象的地址值，销毁函数中传入需要解除的CRITICAL对象的地址值。

销毁函数并不是销毁CRITICAL_SECTION对象的函数，该函数的作用是销毁CRITICAL_SECTION对象使用过的资源。

获取及释放CRITICAL_SECTION对象的函数：

#include 
//获取
VOID EnterCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection   // pointer to critical 
                                         // section object
);

//释放
VOID LeaveCriticalSection(  
  LPCRITICAL_SECTION lpCriticalSection   // address of critical   
                                         // section object  
);

lpCriticalSection参数为获取和释放CRITICAL_SECTION对象的地址值。

示例：

#include 
#include 
#include 
#include 
#define NUM_THREAD 50
unsigned WINAPI threadInc(void *arg);
unsigned WINAPI threadDes(void *arg);
long long num = 0;
CRITICAL_SECTION cs;

int main()
{
    HANDLE hHandles[NUM_THREAD];
    int i;
    InitializeCriticalSection(&cs);  //初始化临界区
    for(i = 0; i < NUM_THREAD; i++)
    {
        if(i % 2)
            hHandles[i] = (HANDLE)_beginthreadex(NULL, 0, threadInc, NULL, 0, NULL);
        else
            hHandles[i] = (HANDLE)_beginthreadex(NULL, 0, threadDes, NULL, 0, NULL);
    }

    WaitForMultipleObject(NUM_THREAD, hHandles, TRUE, INFINITE);
    DeleteCriticalSection(&cs);  //释放临界区
    printf("result: %lld \n", num);

    return 0;
}

unsigned WINAPI threadInc(void *arg)
{
    int i;
    EnterCriticalSection(&cs);  //进入临界区
    for(i = 0; i < 50000000; i++)
        num += 1;
    LeaveCriticalSection(&cs);  //离开临界区
    return 0;
}

unsigned WINAPI threadDes(void *arg)
{
    int i;
    EnterCriticalSection(&cs);  //进入临界区
    for(i = 0; i < 50000000; i++)
        num -= 1;
    LeaveCriticalSection(&cs);  //离开临界区
    return 0;
}

二、基于互斥量对象的同步

基于互斥量对象的同步方法与给予CRITICAL_SECTION对象的同步方法类似。

创建互斥量对象的函数：

HANDLE CreateMutex(  
  LPSECURITY_ATTRIBUTES lpMutexAttributes,  
                       // pointer to security attributes  
  BOOL bInitialOwner,  // flag for initial ownership  
  LPCTSTR lpName       // pointer to mutex-object name  
);  
   
//参数意义：  
//lpMutextAttributes 传递安全相关的配置信息，使用默认安全设置时可以传递NULL  
//bInitialOwner 如果为TRUE，则创建出的互斥量对象属于调用该函数的线程，同时进入non-signaled状态；  
//              如果为FALSE，则创建出的互斥量对象不属于任何线程，此时状态为signaled  
//lpName 用于命名互斥量对象。传入NULL时创建无名的互斥量对象

可以看出，如果互斥量对象不属于任何拥有者，则将进入signaled状态，利用该特点进行同步。另外，互斥量属于内核对象，所以通过如下函数销毁：

BOOL CloseHandle(
    HANDLE hObject  //要销毁内核对象的句柄
);

获取和释放互斥量的函数：

//获取函数  Windows线程创建中介绍的此函数，用于针对单个内核对象验证signaled。
DWORD WaitForSingleObject(  
  HANDLE hHandle,        // handle to object to wait for  
  DWORD dwMilliseconds   // time-out interval in milliseconds  
);

//释放互斥量
BOOL ReleaseMutex(
    HANDLE hMutex  //需要释放的对象的句柄
);

互斥量被某一线程获取时为non-signaled状态，释放时进入signaled状态。因此，可以利用WaitForSingleObject函数验证互斥量是否已分配。

互斥量在WaitForSingleObject函数返回时自动进入non-signaled状态，因为它是“auto-reset”模式的内核对象。

#include   
#include   
#include   
#include   
#define NUM_THREAD 50  
  
unsigned WINAPI threadInc(void * arg);  
unsigned WINAPI threadDes(void * arg);  
  
long long num = 0;  
HANDLE hMutex;  
  
int main()  
{  
    HANDLE tHandles[NUM_THREAD];  
    int i;  
    hMutex = CreateMutex(NULL, FALSE, NULL);  //创建互斥量，此时为signaled状态  
    for (i = 0; i < NUM_THREAD; i++)  
    {  
        if (i % 2)  
            tHandles[i] = (HANDLE)_beginthreadex(NULL, 0, threadInc, NULL, 0, NULL);  
        else  
            tHandles[i] = (HANDLE)_beginthreadex(NULL, 0, threadDes, NULL, 0, NULL);  
    }  
    WaitForMultipleObjects(NUM_THREAD, tHandles, TRUE, INFINITE);  
    CloseHandle(hMutex);  //销毁对象  
    printf("result: %lld \n", num);  

    return 0;  
}  

unsigned WINAPI threadInc(void * arg)  
{  
    int i;  
    WaitForSingleObject(hMutex, INFINITE);  //获取，进入的钥匙  
    for (i = 0; i < 50000000; i++)  
        num += 1;  
    ReleaseMutex(hMutex);  //释放，离开时上交钥匙  
    return 0;  
}  
  
unsigned WINAPI threadDes(void * arg)  
{  
    int i;  
    WaitForSingleObject(hMutex, INFINITE);     
    for (i = 0; i < 50000000; i++)  
        num -= 1;  
    ReleaseMutex(hMutex);  
    return 0;  
}

三、基于信号量对象的同步

创建与销毁函数：

//创建信号量对象
HANDLE CreateSemaphore(  
  LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,  
                       // pointer to security attributes  
  LONG lInitialCount,  // initial count  
  LONG lMaximumCount,  // maximum count  
  LPCTSTR lpName       // pointer to semaphore-object name  
);

//参数意义：  
//lpSemaphoreAttributes  安全配置信息，采用默认安全设置时NULL  
//lInitialCount  指定信号量的初始值，应大于0小于lMaximumCount  
//lMaximumCount  信号量的最大值。该值为1时，信号量变为只能表示0和1的二进制信号量  
//lpName  用于命名信号量对象。传递NULL时创建无名的信号量对象  
//销毁信号量同样使用CloseHandle()函数

可以利用“信号量值为0时进入non-signaled状态，大于0时进入signaled状态”的特性进行同步。向lInitialCount参数传递0时，创建non-signaled状态的信号量对象。而向lMaximumCount传入3时，信号量最大值为3，因此可以实现3个线程同时访问临界区时的同步。

释放信号量对象的函数：

//释放信号量
BOOL ReleaseSemaphore(  
  HANDLE hSemaphore,   // handle to the semaphore object  
  LONG lReleaseCount,  // amount to add to current count  
  LPLONG lpPreviousCount   // address of previous count  
);

//参数意义：  
//hSemaphore  传递需要释放的信号量对象。  
//lReleaseCount  释放以为着信号量值的增加，通过该参数可以指定增加的值。超过最大值则不增加，返回FALSE  
//lpPreviousCount  用于保存之前值得变量地址，不需要是可传递NULL

信号量对象大于0时成为signaled对象，为0时成为non-signaled对象。因此，调用WaitForSingleObject函数时，信号量大于0的情况下才会返回。返回的同时将信号量的值减1，同时进入non-signaled状态。

#include   
#include   
#include   
  
unsigned WINAPI Read(void * arg);  
unsigned WINAPI Accu(void * arg);  
  
static HANDLE semOne;  
static HANDLE semTwo;  
static int num;  
  
int main(int argc, char *argv[])  
{  
    HANDLE hThread1, hThread2;  

    //创建信号量对象,设置为0进入non-signaled状态  
    semOne = CreateSemaphore(NULL, 0, 1, NULL);  

    //创建信号量对象，设置为1进入signaled状态  
    semTwo = CreateSemaphore(NULL, 1, 1, NULL);  

    hThread1 = (HANDLE)_beginthreadex(NULL, 0, Read, NULL, 0, NULL);  
    hThread2 = (HANDLE)_beginthreadex(NULL, 0, Accu, NULL, 0, NULL);  

    WaitForSingleObject(hThread1, INFINITE);  
    WaitForSingleObject(hThread2, INFINITE);  
    CloseHandle(semOne); //销毁  
    CloseHandle(semTwo); //销毁  

    return 0;  
}  

unsigned WINAPI Read(void * arg)  
{  
    int i;  
    for (i = 0; i < 5; i++)  
    {  
        fputs("Input num: ", stdout);  

        //临界区的开始 signaled状态  
        WaitForSingleObject(semTwo, INFINITE);  
        scanf("%d", &num);  

        //临界区的结束 non-signaled状态  
        ReleaseSemaphore(semOne, 1, NULL);  
    }  
    return 0;  
}  

unsigned WINAPI Accu(void * arg)  
{  
    int sum = 0, i;  
    for (i = 0; i < 5; i++)  
    {  
        //临界区的开始 non-signaled状态  
        WaitForSingleObject(semOne, INFINITE);  
        sum += num;  
        //临界区的结束 signaled状态  
        ReleaseSemaphore(semTwo, 1, NULL);  
    }  
    printf("Result: %d \n", sum);  
    return 0;
}

四、基于事件对象的同步

事件同步对象与前2种同步方法相比有很大不同，区别在于：该方法下创建对象时，可以在自动non-signaled状态运行的auto-reset模式和与之相反的manual-reset模式中任选其一。而事件对象的主要特点是可以创建manual-reset模式的对象。

创建事件对象的函数：

HANDLE CreateEvent(  
  LPSECURITY_ATTRIBUTES lpEventAttributes,  
                      // pointer to security attributes  
  BOOL bManualReset,  // flag for manual-reset event  
  BOOL bInitialState, // flag for initial state  
  LPCTSTR lpName      // pointer to event-object name  
);  
   
参数说明：  
//lpEventAttributes  安全配置相关参数，采用默认安全配置时传入NULL  
//bManualReset  传入TRUE时创建manual-reset模式的事件对象，传入FALSE时创建auto-reset模式的事件对象  
//bInitialState  传入TRUE时创建signaled状态，传入FALSE时创建non-signaled状态的事件对象  
//lpName  用于命名事件对象。传递NULL时创建无名的事件对象

当第二个参数传入TRUE时将创建manual-reset模式的事件对象，此时即使WaitForSingleObject函数返回也不会回到non-signaled状态。因此，在这种情况下，需要通过如下2个函数明确更改对象状态。

BOOL ResetEvent(
    HANDLE hEvent  //to the non-signaled
);

BOOL SetEvent(
    HANDLE hEvent  //to the signaled
);

传递事件对象句柄并希望改为non-signed状态时，应调用ResetEvent函数。如果希望改为signaled状态，则可以调用SetEvent函数。