windows多线程互斥和同步

原文地址：https://blog.csdn.net/morewindows/article/details/7442333

地址二：https://blog.csdn.net/lanwanjunxixihaha/article/details/50251785

//win 多线程

#define THREAD_NUM 10
int threadCount=0;
int threadNO=0;

//用于互斥
CRITICAL_SECTION NOCritical;
CRITICAL_SECTION CountCritical;
HANDLE NOMutexHandle;
HANDLE CountMutexHandle;

//用于同步
HANDLE eventHandle;
HANDLE pulseEventHandle;
HANDLE semaphoreHandle;

/*
互斥：不能同时使用一个资源
同步: 在不能同时使用的基础上，强调先后顺序
*/

unsigned int _stdcall winThread(void*param){

// 测试同步

//临界区只能用于互斥，不同用于同步
//EnterCriticalSection(&NOCritical);
//int no = threadNO;
//LeaveCriticalSection(&NOCritical);

//事件可用于同步
//int no = threadNO;
//SetEvent(eventHandle);
PulseEvent(eventHandle); //PulseEvent在自动复位的情况下与SetEvent的作用是一样的

//互斥量不能用于同步，只能用于互斥,与临界区相似
//int no = threadNO;
//ReleaseMutex(NOMutexHandle);

//信号灯可用于同步
int no = threadNO;
ReleaseSemaphore(semaphoreHandle,1,nullptr);

// 测试互斥

//测试手动复位事件的同时唤醒
WaitForSingleObject(pulseEventHandle, INFINITE);

//临界区可用于互斥
//EnterCriticalSection(&CountCritical);
//threadCount++;
//std::cout << no << " " << threadCount << std::endl;
出现异常后，各线程死锁了,因为临界区不能得到正常释放
//if (threadCount == 8)
//  return 0;
//LeaveCriticalSection(&CountCritical);

//互斥量用于互斥
WaitForSingleObject(CountMutexHandle,INFINITE);
threadCount++;
std::cout << no << " " << threadCount << std::endl;
//即使这里有一个线程会异常退出，且没有释放互斥量，互斥量仍能正常释放,这就是互斥量比临界区优秀的地方
if (threadCount == 8)
return 0;
ReleaseMutex(CountMutexHandle);

return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
//参数：
//1 不重要，不解释
//2 是否手动管理，在SetEvent后，是否自动ResetEvent，一般填false表自动
//3 创建后，是否设置置位,也就是触发状态
//4 不重要，不解释
eventHandle = CreateEvent(nullptr, false, false, nullptr);
pulseEventHandle = CreateEvent(nullptr, true, false, nullptr);
//参数:
//1 不重要，不解释
//2 创建后，默认有几个资源
//3 每次调用ReleaseSemaphore最多可释放多少个，一般为1个
//4 不重要，不解释
semaphoreHandle = CreateSemaphore(nullptr,0,1,nullptr);

//参数:
//1 不重要，不解释
//2 是否让创建线程获得这个互斥量，获得了，就相当于触发了
//3 不重要，不解释
CountMutexHandle = CreateMutex(nullptr, false, nullptr);
NOMutexHandle = CreateMutex(nullptr, false, nullptr);
InitializeCriticalSection(&NOCritical);
InitializeCriticalSection(&CountCritical);

HANDLE handle[THREAD_NUM];
while (threadNO < THREAD_NUM){
handle[threadNO]=(HANDLE)_beginthreadex(nullptr, 0, winThread, nullptr, 0, nullptr);

//临界区只能用于互斥，不同用于同步,线程拥有权，使得同一线程，可Enter多次,却不必Leave
//EnterCriticalSection(&NOCritical);
//threadNO++;
//LeaveCriticalSection(&NOCritical);

//事件可用于同步
//WaitForSingleObject(eventHandle, INFINITE);
//threadNO++;

//临界区不能用于同步，原因与临界区相似
//WaitForSingleObject(NOMutexHandle, INFINITE);
//threadNO++;

//信号灯可用于同步
WaitForSingleObject(semaphoreHandle, INFINITE);
threadNO++;
}
Sleep(10);
//唤醒手动复位事件,如果没有这句，所有的线程就都卡住了
PulseEvent(pulseEventHandle);

//等待所有的线程都结束
WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);

//释放内核对象
while (--threadCount >= 0){
CloseHandle(handle[threadCount]);
}
CloseHandle(CountMutexHandle);
CloseHandle(NOMutexHandle);
CloseHandle(eventHandle);
CloseHandle(pulseEventHandle);
DeleteCriticalSection(&NOCritical);
DeleteCriticalSection(&CountCritical);
system("pause");
return 0;
}
————————————————
版权声明：本文为CSDN博主「lanwanjunxixihaha」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/lanwanjunxixihaha/article/details/50251785