C++多线程互斥锁信号量事件临界区

一、互斥锁

1、先熟悉熟悉API

1，创建互斥锁，并反正一个句柄
HANDLE CreateMutex(
LPSECURITY_ATTRIBUTESlpMutexAttributes, // 指向安全属性的指针
BOOLbInitialOwner, // 初始化互斥对象的所有者，一般设置为FALSE
LPCTSTRlpName // 互斥对象名
);2，释放互斥对象的控制权
BOOL ReleaseMutex(
HANDLE hMutex //已创建Mutex的句柄
);3，打开互斥锁，返回句柄
HANDLE OpenMutex(
DWORDdwDesiredAccess, // 互斥体的访问权限
BOOLbInheritHandle, //如希望子进程能够继承句柄，则为TRUE
LPCTSTRlpName // 互斥锁名字
);4，等待目标返回
DWORD WaitForSingleObject(
HANDLE hHandle, //目标句柄
DWORD dwMilliseconds //等待时间 ,毫秒记，INFINITE为永久等待
);

一个简单的互斥锁例子来实现多线程同步

#include<Windows.h>
#include<stdlib.h>
#include<iostream>
using namespace std;
static int g_count = 100;class Lock
{
public:Lock(char*szName){hd = OpenMutex(MUTEX_ALL_ACCESS, NULL, (LPCWSTR)szName);WaitForSingleObject(hd, INFINITE);Sleep(1500);//测试用:等待1.5秒，正式类中不应有}~Lock(){ReleaseMutex(hd);}static bool InitLock(char*szName){if (!OpenMutex(MUTEX_ALL_ACCESS, NULL, (LPCWSTR)szName)){if (!CreateMutex(NULL, NULL, (LPCWSTR)szName))return false;return true;}return false;}HANDLE hd;
};UINT address1(LPVOID lparam)
{while (1){Lock lc("_temp_lock");cout << g_count-- << "---" << "address1" << endl;}
}UINT address2(LPVOID lparam)
{while (1){Lock lc("_temp_lock");cout << g_count-- << "---" << "address2" << endl;}
}
int main(int argc, char*argv[])
{if(!Lock::InitLock("_temp_lock"))//创建互斥锁失败return -1;CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)address1, NULL, NULL, NULL);//开启线程1CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)address2, NULL, NULL, NULL);//开启线程2system("pause");return 0;
}

原理浅析：Lock::InitLock()来创建互斥锁，在本demo中，同步是按照CreateThread的创建顺序。创建了一个Lock类，当生成对象的时候就等待，一旦当互斥锁没有控制权，等待即结束，便向下执行，对象析构的时候就释放控制权，以此类推循环。
ps：mutex作用范围在系统层，使用mutex效率并不是太高，使用临界区（作用范围在进程）效率比较高

二、信号量

1，先熟悉熟悉API

CreateSemaphore（） 创建一个信号量  OpenSemaphore（） 打开一个信号量  ReleaseSemaphore（） 释放信号量 WaitForSingleObject（） 等待信号量

2，举个简单的小例子

#include <stdio.h>
#include <Windows.h>  #define THREAD_NUM 20
#define SEM_NAME "THREAD_SEMAPHORE"HANDLE g_hSem = NULL;
HANDLE g_hThread[THREAD_NUM];void WINAPI ThreadFun(void* param)
{printf("进入线程： %u,并等待\n", GetCurrentThreadId());WaitForSingleObject(g_hSem, INFINITE);printf("线程： %u 获得信号量\n", GetCurrentThreadId());long dwSem = 0;if (!ReleaseSemaphore(g_hSem, 1, &dwSem))return;printf("目前资源数：%u\n", dwSem);
}int  main(int argc, char*argv[])
{g_hSem = CreateSemaphoreA(NULL, 0, 5, SEM_NAME);g_hSem = OpenSemaphoreA(SEMAPHORE_MODIFY_STATE, FALSE, SEM_NAME);for (int i = 0; i < THREAD_NUM; ++i){DWORD dwThreadID = 0;g_hThread[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadFun, NULL, 0, &dwThreadID);}WaitForMultipleObjects(THREAD_NUM, g_hThread, TRUE, INFINITE);printf("全部执行完了\n");return 0;
}

ps：信号量可以说在平常的使用中用的比较少，一般的用途在控制并发线程数量，抢占资源问题。

三、事件

1，先熟悉熟悉API

HANDLE CreateEvent( //创建事件
LPSECURITY_ATTRIBUTES lpEventAttributes,// 安全属性
BOOL bManualReset,// 复位方式
BOOL bInitialState,// 初始状态
LPCTSTR lpName // 对象名称
);HANDLE OpenEvent( //打开事件
DWORD dwDesiredAccess,
BOOL bInheritHandle,
LPCTSTR lpName
);BOOL ResetEvent(//事件对象设置为无信号状态。
HANDLE hEvent
);BOOL SetEvent(HANDLE hEvent);//事件对象设置为有信号状态。 BOOL PulseEvent(HANDLE hEvent)//事件对象设置为有信号状态，脉冲一个事件WaitForSingleObject（） 等待信号量

2，举个简单的小例子

#include <stdio.h>
#include <Windows.h>
HANDLE g_hEvent;UINT address1(LPVOID lparam)
{printf("进入线程了，等待5秒\n");WaitForSingleObject(g_hEvent, INFINITE);printf("等待结束了，向下执行了！\n");return 0;
}UINT address2(LPVOID lparam)
{Sleep(5000);SetEvent(g_hEvent);return 0;
}int main(int argc, char*argv[])
{g_hEvent=CreateEvent(NULL, true, FALSE, NULL);ResetEvent(g_hEvent);CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)address1, NULL, NULL, NULL);//开启线程1CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)address2, NULL, NULL, NULL);//开启线程2system("pause");return 0;
}

ps：本小例模拟了的两个线程间的同步，address2来控制address1的执行，事件在多线程程序中的应用比较多，比较重要，定要熟练掌握。

四、临界区

1，先熟悉熟悉API

void InitializeCriticalSection(//初始化临界区LPCRITICAL_SECTION lpCriticalSection); void WINAPI DeleteCriticalSection( //删除临界区
_Inout_ LPCRITICAL_SECTION lpCriticalSection);VOID WINAPI EnterCriticalSection( //进入临界区  __inout LPCRITICAL_SECTION lpCriticalSection
); VOID WINAPI LeaveCriticalSection(//离开临界区_Inout_ LPCRITICAL_SECTION lpCriticalSection);

2，举个简单的小例子

#include <stdio.h>
#include <Windows.h>CRITICAL_SECTION g_cs;
int g_nIndex = 20;UINT address1(LPVOID lparam)
{while(true){if (10 == g_nIndex)return 1;EnterCriticalSection(&g_cs);printf("address111线程，index=%d\n",g_nIndex);g_nIndex--;LeaveCriticalSection(&g_cs);}return 0;}UINT address2(LPVOID lparam)
{while (true){if (0 == g_nIndex)return 1;EnterCriticalSection(&g_cs);printf("address222线程，index=%d\n", g_nIndex);--g_nIndex;LeaveCriticalSection(&g_cs);}return 0;
}
int main(int argc, char*argv[])
{InitializeCriticalSection(&g_cs);CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)address1, NULL, NULL, NULL);//开启线程1CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)address2, NULL, NULL, NULL);//开启线程2system("pause");DeleteCriticalSection(&g_cs);return 0;
}

ps:小例中，address1被临界区一直占用到到address1退出，address2才能进入临界区，进行直到退出，与mutex交替执行不同，临界区比较简单且最易用。

更多文章：http://blog.csdn.net/what951006?viewmode=list
powered by:小乌龟在大乌龟背上~