Windows————线程同步的四种方式
一、基于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);
int 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); //释放临界区
return 0;
}
unsigned WINAPI threadInc(void *arg)
{
int i;
EnterCriticalSection(&cs); //进入临界区
for(i = 0; i < 50000000; i++)
{
num += 1;
printf("%d\n", num);
Sleep(50);
}
LeaveCriticalSection(&cs); //离开临界区
return 0;
}
unsigned WINAPI threadDes(void *arg)
{
int i;
EnterCriticalSection(&cs); //进入临界区
for(i = 0; i < 50000000; i++)
{
num += 1;
printf("%d\n", num);
Sleep(50);
}
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函数。
示例：
#include
#include
#include
#define STR_LEN 100
unsigned WINAPI NumberOfA(void *arg);
unsigned WINAPI NumberOfOthers(void *arg);
static char str[STR_LEN];
static HANDLE hEvent;
int main(int argc, char *argv[])
{
HANDLE hThread1, hThread2;
//以non-signaled创建manual-reset模式的事件对象
hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
hThread1 = (HANDLE)_beginthreadex(NULL, 0, NumberOfA, NULL, 0, NULL);
hThread2 = (HANDLE)_beginthreadex(NULL, 0, NumberOfOthers, NULL, 0, NULL);
fputs("Input string: ", stdout);
fgets(str, STR_LEN, stdin);
//读入字符串后改为signaled状态
SetEvent(hEvent);
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(hThread2, INFINITE);
//non-signaled 如果不更改，对象继续停留在signaled
ResetEvent(hEvent);
CloseHandle(hEvent);
return 0;
}
unsigned WINAPI NumberOfA(void *arg)
{
int i, cnt = 0;
WaitForSingleObject(hEvent, INFINITE);
for (i = 0; str[i] != 0; i++)
{
if (str[i] == 'A')
cnt++;
}
printf("Num of A: %d \n", cnt);
return 0;
}
unsigned WINAPI NumberOfOthers(void *arg)
{
int i, cnt = 0;
WaitForSingleObject(hEvent, INFINITE);
for (i = 0; str[i] != 0; i++)
{
if (str[i] != 'A')
cnt++;
}
printf("Num of others: %d \n", cnt - 1);
return 0;
}