VC++线程同步的四种方式(事件(Event)、信号量(semaphore)、互斥量(mutex)、临界区(Critical section))
一、概述:为什么要做线程同步？
在程序中使用多线程时，一般很少有多个线程能在其生命期内进行完全独立的操作。更多的情况是一些线程进行某些处理操作，而其他的线程必须对其处理结果进行访问。正常情况下对这种处理结果的访问应当在其处理任务完成后进行。
如果不采取适当的措施，其他线程往往会在线程处理任务结束前就去访问处理结果，这就很有可能得到有关处理结果的错误访问,例如，多个线程同时访问同一个全局变量，如果都是读取操作，则不会出现问题。如果一个线程负责改变此变量的值，
而其他线程负责同时读取变量内容，则不能保证读取到的数据是经过写线程修改后的。为了确保读线程读取到的是经过修改的变量，就必须在向变量写入数据时禁止其他线程对其的任何访问，直至赋值过程结束后再解除对其他线程的访问限制。
这种保证线程能了解其他线程任务处理结束后的处理结果而采取的保护措施即为线程同步
#include "stdafx.h"
#include
#include
using namespace std;
//示例1,演示两个线程同时访问同一个变量(模拟售票).
//线程1和线程2同时售票,票号1 - 30。
int g_iTicket = 30;
//线程函数1
unsigned long __stdcall ThreadFunc1(void* lparm)
{
while (g_iTicket > 0)
{
cout << "thread1售出票号:"<< g_iTicket << endl;
g_iTicket--;
_sleep(1);
}
return 0;
}
//线程函数2
unsigned long __stdcall ThreadFunc2(void* lparm)
{
while (g_iTicket > 0)
{
cout << "thread2售出票号:"<< g_iTicket << endl;
g_iTicket--;
_sleep(1);
}
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
//创建线程1和线程2开始售票(总票数g_iTicket=30)
CreateThread(NULL, 0, ThreadFunc1, NULL, 0, NULL);
CreateThread(NULL, 0, ThreadFunc2, NULL, 0, NULL);
int i = 0;
cin >> i;
return 0;
}
//测试结果:
从示例1可以看出,线程1和线程2买出相同票号的票,显然这不是我们想要的结果.
二、线程同步
2.1 线程之间通信的两个基本问题是互斥和同步。
2.2 线程同步是指线程之间所具有的一种制约关系，一个线程的执行依赖另一个线程的消息，
当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒。
2.3 线程互斥是指对于共享的操作系统资源（指的是广义的”资源”，而不是Windows的.res文件，
譬如全局变量就是一种共享资源），在各线程访问时的排它性。当有若干个线程都要使用某一共享资源时，
任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源。
2.4 线程互斥是一种特殊的线程同步。实际上，互斥和同步对应着线程间通信发生的两种情况：
2.4.1 当有多个线程访问共享资源而不使资源被破坏时。
2.4.2 当一个线程需要将某个任务已经完成的情况通知另外一个或多个线程时。
2.5 从大的方面讲，线程的同步可分用户模式的线程同步和内核对象的线程同步两大类。
用户模式中线程的同步方法主要有原子访问和临界区等方法。其特点是同步速度特别快，适合于对线程运行速度有严格要求的场合。内核对象的线程同步则主要由事件、等待定时器、信号量以及信号灯等内核对象构成。由于这种同步机制使用了内核对象，使用时必须将线程从用户模式切换到内核模式，而这种转换一般要耗费近千个CPU周期，因此同步速度较慢，但在适用性上却要远优于用户模式的线程同步方式。
2.6 在WIN32中，同步机制主要有以下几种：
2.6.1 事件(Event);
2.6.2 信号量(semaphore);
2.6.3 互斥量(mutex);
2.6.4 临界区(Critical section)。
三、VC++的四种线程同步
3.1 临界区(Critical section)
临界区（Critical Section）是一段独占对某些共享资源访问的代码，在任意时刻只允许一个线程对共享资源进行访问。
如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持
续到进入临界区的线程离开。
临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。
临界区在使用时以CRITICAL_SECTION结构对象保护共享资源，并分别用EnterCriticalSection()和LeaveCriticalSection()
函数去标识和释放一个临界区。所用到的CRITICAL_SECTION结构对象必须经过InitializeCriticalSection()的初始化后才能使用，
而且必须确保所有线程中的任何试图访问此共享资源的代码都处在此临界区的保护之下。否则临界区将不会起到应有的作用，共享资源依然有被破坏的可能。
//示例2,演示临界区保护全局变量(模拟售票).
//线程1和线程2同时售票,票号1 - 30。
int g_iTicket = 30; //定义全局变量(总票数)
CRITICAL_SECTION g_cs; //定义临界区句柄
//线程函数1
unsigned long __stdcall ThreadFunc1(void* lparm)
{
while (g_iTicket > 0)
{
//1. 判断是否有线程占有贡享资源,如果没有则直线下面的代码,否则阻塞等待其他线程释放共享资源
EnterCriticalSection(&g_cs);
//2. 线程1开始售票
cout << "thread1售出票号:"<< g_iTicket << endl;
g_iTicket--;
_sleep(100);
//3. 执行完代码,释放共享资源,让其他线程执行
LeaveCriticalSection(&g_cs);
}
return 0;
}
//线程函数2
unsigned long __stdcall ThreadFunc2(void* lparm)
{
while (g_iTicket > 0)
{
//1. 判断是否有线程占有贡享资源,如果没有则直线下面的代码,否则阻塞等待其他线程释放共享资源
EnterCriticalSection(&g_cs);
//2. 线程2开始售票
cout << "thread2售出票号:"<< g_iTicket << endl;
g_iTicket--;
_sleep(100);
//3. 执行完代码,释放共享资源,让其他线程执行
LeaveCriticalSection(&g_cs);
}
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
//1. 初始化临界区对象
InitializeCriticalSection(&g_cs);
//2. 创建线程1和线程2开始售票(总票数g_iTicket=30)
CreateThread(NULL, 0, ThreadFunc1, NULL, 0, NULL);
CreateThread(NULL, 0, ThreadFunc2, NULL, 0, NULL);
int i = 0;
cin >> i;
//3. 删除临界区对象
DeleteCriticalSection(&g_cs);
return 0;
}
//测试结果:
测试结果,使用临界区实现了同步,避免了一票多卖的情况。
3.2 事件(Event)
事件(Event)是WIN32提供的最灵活的线程间同步方式，事件可以处于激发状态(signaled or true)或
未激发状态(unsignal or false)。根据状态变迁方式的不同，事件可分为两类：
3.1.2 手动设置：这种对象只可能用程序手动设置，在需要该事件或者事件发
生时，采用SetEvent及ResetEvent来进行设置。
3.2.2 自动恢复：一旦事件发生并被处理后，自动恢复到没有事件状态，不需
要再次设置。
使用”事件”机制应注意以下事项：
3.2.3 如果跨进程访问事件，必须对事件命名，在对事件命名的时候，要注意
不要与系统命名空间中的其它全局命名对象冲突；
3.2.4 事件是否要自动恢复；
3.2.5 事件的初始状态设置。
由于event对象属于内核对象，故进程B可以调用OpenEvent函数通过对象的名字获得进程A中event对象
的句柄，然后将这个句柄用于ResetEvent、SetEvent和WaitForMultipleObjects等函数中。此法可
以实现一个进程的线程控制另一进程中线程的运行，例如：
HANDLE hEvent=OpenEvent(EVENT_ALL_ACCESS,true,"MyEvent");
ResetEvent(hEvent);
//示例3,演示事件保护全局变量(模拟售票).
//线程1和线程2同时售票,票号1 - 30。
int g_iTicket = 30; //定义全局变量(总票数)
HANDLE hEvent; //定义事件句柄
//线程函数1
unsigned long __stdcall ThreadFunc1(void* lparm)
{
while (g_iTicket > 0)
{
//1. 等待对象为有信号状态
WaitForSingleObject(hEvent, INFINITE);
//2. 线程1开始售票
cout << "thread1售出票号:"<< g_iTicket << endl;
g_iTicket--;
_sleep(100);
SetEvent(hEvent);
}
return 0;
}
//线程函数2
unsigned long __stdcall ThreadFunc2(void* lparm)
{
while (g_iTicket > 0)
{
//1. 等待对象为有信号状态
WaitForSingleObject(hEvent, INFINITE);
//2. 线程2开始售票
cout << "thread2售出票号:"<< g_iTicket << endl;
g_iTicket--;
_sleep(100);
SetEvent(hEvent);
}
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
//1. 创建线程1和线程2开始售票(总票数g_iTicket=30)
CreateThread(NULL, 0, ThreadFunc1, NULL, 0, NULL);
CreateThread(NULL, 0, ThreadFunc2, NULL, 0, NULL);
//2. 创建事件对象
hEvent = CreateEvent(NULL, FALSE, TRUE, L"event");
int i = 0;
cin >> i;
return 0;
}
//测试结果:
测试结果,使用事件实现了同步,避免了一票多卖的情况。
3.3 信号量(semaphore)
信号量是维护0到指定最大值之间的同步对象。信号量状态在其计数大于0时是有
信号的，而其计数是0时是无信号的。信号量对象在控制上可以支持有限数量共
享资源的访问。
信号量的特点和用途可用下列几句话定义：
3.3.1 如果当前资源的数量大于0，则信号量有效；
3.3.2 如果当前资源数量是0，则信号量无效；
3.3.3 系统决不允许当前资源的数量为负值；
3.3.4 当前资源数量决不能大于最大资源数量。
3.3.5 创建信号量函数原型:
HANDLE CreateSemaphore(
PSECURITY_ATTRIBUTE psa, //信号量的安全属性
LONG lInitialCount, //开始时可供使用的资源数
LONG lMaximumCount, //最大资源数
PCTSTR pszName); //信号量的名称
3.3.6 释放信号量函数,通过调用ReleaseSemaphore函数,线程就能够
对信标的当前资源数量进行递增，该函数原型为：
BOOL WINAPI ReleaseSemaphore(
HANDLE hSemaphore, //要增加的信号量句柄
LONG lReleaseCount, //信号量的当前资源数增加lReleaseCount
LPLONG lpPreviousCount); //增加前的数值返回
3.3.7 打开信号量,和其他核心对象一样，信号量也可以通过名字跨进
程访问，打开信号量的API为:
HANDLE OpenSemaphore (
DWORD fdwAccess, //access
BOOL bInherithandle, //如果允许子进程继承句柄，则设为TRUE
PCTSTR pszName); //指定要打开的对象的名字
//示例3,演示信号量保护全局变量(模拟售票).
//线程1和线程2同时售票,票号1 - 30。
int g_iTicket = 30; //定义全局变量(总票数)
HANDLE g_hSemaphore; //定义信号量句柄
//线程函数1
unsigned long __stdcall ThreadFunc1(void* lparm)
{
while (g_iTicket > 0)
{
long count;
//1. 等待信号量为有信号状态
WaitForSingleObject(g_hSemaphore, INFINITE);
//2. 线程1开始售票
cout << "thread1售出票号:"<< g_iTicket << endl;
g_iTicket--;
_sleep(100);
//3. 释放信号量
ReleaseSemaphore(g_hSemaphore, 1, &count);
}
return 0;
}
//线程函数2
unsigned long __stdcall ThreadFunc2(void* lparm)
{
while (g_iTicket > 0)
{
long count;
//1. 等待信号量为有信号状态
WaitForSingleObject(g_hSemaphore, INFINITE);
//2. 线程2开始售票
cout << "thread2售出票号:"<< g_iTicket << endl;
g_iTicket--;
_sleep(100);
//3. 释放信号量
ReleaseSemaphore(g_hSemaphore, 1, &count);
}
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
//1. 创建信号量
g_hSemaphore = CreateSemaphore(NULL, 1, 100, L"sema");
//2. 创建线程1和线程2开始售票(总票数g_iTicket=30)
CreateThread(NULL, 0, ThreadFunc1, NULL, 0, NULL);
CreateThread(NULL, 0, ThreadFunc2, NULL, 0, NULL);
int i = 0;
cin >> i;
return 0;
}
//测试结果:
测试结果,使用信号量实现了同步,避免了一票多卖的情况。
3.4 互斥量(mutex)
采用互斥对象机制.只有拥有互斥对象的线程才有访问公共资源的权限,
因为互斥对象只有一个,所以能保证公共资源不会同时被多个线程访问.
互斥不仅能实现同一应用程序的公共资源安全共享,还能实现不同应用
程序的公共资源安全共享。
//示例3,演示互斥量量保护全局变量(模拟售票).
//线程1和线程2同时售票,票号1 - 30。
int g_iTicket = 30; //定义全局变量(总票数)
HANDLE g_hMutex; //定义互斥对象句柄
//线程函数1
unsigned long __stdcall ThreadFunc1(void* lparm)
{
while (g_iTicket > 0)
{
//1. 等待信号量为有信号状态
WaitForSingleObject(g_hMutex, INFINITE);
//2. 线程1开始售票
cout << "thread1售出票号:"<< g_iTicket << endl;
g_iTicket--;
_sleep(100);
//3. 释放锁
ReleaseMutex(g_hMutex);
}
return 0;
}
//线程函数2
unsigned long __stdcall ThreadFunc2(void* lparm)
{
while (g_iTicket > 0)
{
//1. 等待信号量为有信号状态
WaitForSingleObject(g_hMutex, INFINITE);
//2. 线程2开始售票
cout << "thread2售出票号:"<< g_iTicket << endl;
g_iTicket--;
_sleep(100);
//3. 释放锁
ReleaseMutex(g_hMutex);
}
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
//1. 创建互斥对象
g_hMutex = CreateMutex(NULL, false, "mutex");
//2. 创建线程1和线程2开始售票(总票数g_iTicket=30)
CreateThread(NULL, 0, ThreadFunc1, NULL, 0, NULL);
CreateThread(NULL, 0, ThreadFunc2, NULL, 0, NULL);
int i = 0;
cin >> i;
return 0;
}
//测试结果:
测试结果,使用互斥量实现了同步,避免了一票多卖的情况。
四、总结。
4.1 临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。
4.2 互斥量:为协调一起对一个共享资源的单独访问而设计的。
4.3 信号量:为控制一个具备有限数量用户资源而设计。
4.4 事件:用来通知线程有一些事件已发生，从而启动后继任务的开始。
4.5 不论使用哪种方式,应该避免死锁,造成线程互相等待。
参考:https://www.cnblogs.com/yhlboke-1992/p/9315263.html