C++线程同步的四种方式（Windows）

我不是女神ヾ 2023-03-03 12:26 5阅读 0赞

## 一、为什么要进行线程同步？ ##

在程序中使用多线程时，一般很少有多个线程能在其生命期内进行完全独立的操作。更多的情况是一些线程进行某些处理操作，而其他的线程必须对其处理结果进行了解。正常情况下对这种处理结果的了解应当在其处理任务完成后进行。如果不采取适当的措施，其他线程往往会在线程处理任务结束前就去访问处理结果，这就很有可能得到有关处理结果的错误了解。例如，多个线程同时访问同一个全局变量，如果都是读取操作，则不会出现问题。如果一个线程负责改变此变量的值，而其他线程负责同时读取变量内容，则不能保证读取到的数据是经过写线程修改后的。为了确保读线程读取到的是经过修改的变量，就必须在向变量写入数据时禁止其他线程对其的任何访问，直至赋值过程结束后再解除对其他线程的访问限制。这种保证线程能了解其他线程任务处理结束后的处理结果而采取的保护措施即为线程同步。

两个线程同时对一个全局变量进行加操作，演示了多线程资源访问冲突的情况。代码如下：

#include "stdafx.h"
    #include<windows.h>
    #include<iostream>
    using namespace std;
    
    int number = 1;
    
    unsigned long __stdcall ThreadProc1(void* lp) {
    	while (number < 100) {
    		cout << "thread 1 :"<<number << endl;
    		++number;
    		_sleep(100);
    	}
    
    	return 0;
    }
    
    unsigned long __stdcall ThreadProc2(void* lp) {
    	while (number < 100) {
    		cout << "thread 2 :"<<number << endl;
    		++number;
    		_sleep(100);
    	}
    
    	return 0;
    }
    
    int main() {
    	CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
    	CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);
    
    	Sleep(10*1000);
    
    	system("pause");
        return 0;
    }

运行结果：  
![这里写图片描述][aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwNzA1MjIyODI3OTkz]  
可以看到有时两个线程计算的值相同，不是我们想要的结果。

## 二、关于线程同步 ##

线程之间通信的两个基本问题是互斥和同步。

*  *线程同步*是指线程之间所具有的一种制约关系，一个线程的执行依赖另一个线程的消息，当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒。
 *  *线程互斥*是指对于共享的操作系统资源（指的是广义的”资源”，而不是Windows的.res文件，譬如全局变量就是一种共享资源），在各线程访问时的排它性。当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源。

线程互斥是一种特殊的线程同步。实际上，互斥和同步对应着线程间通信发生的两种情况：

*  当有多个线程访问共享资源而不使资源被破坏时；
 *  当一个线程需要将某个任务已经完成的情况通知另外一个或多个线程时。

从大的方面讲，线程的同步可分用户模式的线程同步和内核对象的线程同步两大类。

*  用户模式中线程的同步方法主要有原子访问和临界区等方法。其特点是同步速度特别快，适合于对线程运行速度有严格要求的场合。
 *  内核对象的线程同步则主要由事件、等待定时器、信号量以及信号灯等内核对象构成。由于这种同步机制使用了内核对象，使用时必须将线程从用户模式切换到内核模式，而这种转换一般要耗费近千个CPU周期，因此同步速度较慢，但在适用性上却要远优于用户模式的线程同步方式。

在WIN32中（区别于Linux，其实也差不多），同步机制主要有以下几种：  
（1）事件(Event);  
（2）信号量(semaphore);  
（3）互斥量(mutex);  
（4）临界区(Critical section)。

## 三、Win32中的四种同步方式 ##

### 【1】临界区 ###

临界区（Critical Section）是一段独占对某些共享资源访问的代码，在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。

临界区在使用时以`CRITICAL_SECTION`结构对象保护共享资源，并分别用`EnterCriticalSection()`和`LeaveCriticalSection()`函数去标识和释放一个临界区。所用到的`CRITICAL_SECTION`结构对象必须经过`InitializeCriticalSection()`的初始化后才能使用，而且必须确保所有线程中的任何试图访问此共享资源的代码都处在此临界区的保护之下。否则临界区将不会起到应有的作用，共享资源依然有被破坏的可能。代码如下：

#include "stdafx.h"
    #include<windows.h>
    #include<iostream>
    using namespace std;
    
    int number = 1;	//定义全局变量
    CRITICAL_SECTION Critical;		//定义临界区句柄
    
    unsigned long __stdcall ThreadProc1(void* lp) {
    	while (number < 100) {
    		EnterCriticalSection(&Critical);
    		cout << "thread 1 :"<<number << endl;
    		++number;
    		_sleep(100);
    		LeaveCriticalSection(&Critical);
    	}
    
    	return 0;
    }
    
    unsigned long __stdcall ThreadProc2(void* lp) {
    	while (number < 100) {
    		EnterCriticalSection(&Critical);
    		cout << "thread 2 :"<<number << endl;
    		++number;
    		_sleep(100);
    		LeaveCriticalSection(&Critical);
    	}
    
    	return 0;
    }
    
    int main() {
    	InitializeCriticalSection(&Critical);	//初始化临界区对象
    	CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
    	CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);
    
    	Sleep(10*1000);
    	system("pause");
        return 0;
    }

运行结果：  
![这里写图片描述][aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwNzA1MjI0ODI2Mjcy]  
可以看到，也实现了有序输出，实现了线程同步。

### 【2】事件 ###

事件(Event)是WIN32提供的最灵活的线程间同步方式，事件可以处于激发状态(signaled or true)或未激发状态(unsignal or false)。根据状态变迁方式的不同，事件可分为两类：  
（1）手动设置：这种对象只可能用程序手动设置，在需要该事件或者事件发生时，采用`SetEvent`及`ResetEvent`来进行设置。  
（2）自动恢复：一旦事件发生并被处理后，自动恢复到没有事件状态，不需要再次设置。

使用”事件”机制应注意以下事项：  
（1）如果跨进程访问事件，必须对事件命名，在对事件命名的时候，要注意不要与系统命名空间中的其它全局命名对象冲突；  
（2）事件是否要自动恢复；  
（3）事件的初始状态设置。

由于event对象属于内核对象，故进程B可以调用`OpenEvent`函数通过对象的名字获得进程A中event对象的句柄，然后将这个句柄用于`ResetEvent`、`SetEvent`和`WaitForMultipleObjects`等函数中。此法可以实现一个进程的线程控制另一进程中线程的运行，例如：

HANDLE hEvent = OpenEvent(EVENT_ALL_ACCESS, true, "MyEvent"); 
    ResetEvent(hEvent);

代码示例：

#include "stdafx.h"
    #include<windows.h>
    #include<iostream>
    using namespace std;
    
    int number = 1;	//定义全局变量
    HANDLE hEvent;	//定义事件句柄
    
    unsigned long __stdcall ThreadProc1(void* lp) {
    	while (number < 100) {
    		WaitForSingleObject(hEvent, INFINITE);	//等待对象为有信号状态
    		cout << "thread 1 :"<<number << endl;
    		++number;
    		_sleep(100);
    		SetEvent(hEvent);
    	}
    
    	return 0;
    }
    
    unsigned long __stdcall ThreadProc2(void* lp) {
    	while (number < 100) {
    		WaitForSingleObject(hEvent, INFINITE);	//等待对象为有信号状态
    		cout << "thread 2 :"<<number << endl;
    		++number;
    		_sleep(100);
    		SetEvent(hEvent);
    	}
    
    	return 0;
    }
    
    int main() {
    	hEvent = CreateEvent(NULL, FALSE, TRUE, "event");
    	CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
    	CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);
    
    	Sleep(10*1000);
    	system("pause");
        return 0;
    }

运行结果：  
![这里写图片描述][aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwNzA1MjIzNzQ0NDk0]  
可以看到，实现了有序输出，实现了线程同步。

### 【3】信号量 ###

信号量是维护0到指定最大值之间的同步对象。信号量状态在其计数大于0时是有信号的，而其计数是0时是无信号的。信号量对象在控制上可以支持有限数量共享资源的访问。

信号量的特点和用途可用下列几句话定义：  
（1）如果当前资源的数量大于0，则信号量有效；  
（2）如果当前资源数量是0，则信号量无效；  
（3）系统决不允许当前资源的数量为负值；  
（4）当前资源数量决不能大于最大资源数量。

创建信号量

函数原型为：

HANDLE CreateSemaphore (
      　PSECURITY_ATTRIBUTE psa, //信号量的安全属性
    　  LONG lInitialCount, //开始时可供使用的资源数
    　  LONG lMaximumCount, //最大资源数
       PCTSTR pszName);     //信号量的名称

释放信号量

通过调用`ReleaseSemaphore`函数，线程就能够对信标的当前资源数量进行递增，该函数原型为：

BOOL WINAPI ReleaseSemaphore(
      　HANDLE hSemaphore,   //要增加的信号量句柄
      　LONG lReleaseCount, //信号量的当前资源数增加lReleaseCount
      　LPLONG lpPreviousCount  //增加前的数值返回
       );

打开信号量

和其他核心对象一样，信号量也可以通过名字跨进程访问，打开信号量的API为：

HANDLE OpenSemaphore (
      　DWORD fdwAccess,      //access
      　BOOL bInherithandle,  //如果允许子进程继承句柄，则设为TRUE
      　PCTSTR pszName  //指定要打开的对象的名字
      );

代码示例：

#include "stdafx.h"
    #include<windows.h>
    #include<iostream>
    using namespace std;
    
    int number = 1;	//定义全局变量
    HANDLE hSemaphore;	//定义信号量句柄
    
    unsigned long __stdcall ThreadProc1(void* lp) {
    	long count;
    	while (number < 100) {
    		WaitForSingleObject(hSemaphore, INFINITE);	//等待信号量为有信号状态
    		cout << "thread 1 :"<<number << endl;
    		++number;
    		_sleep(100);
    		ReleaseSemaphore(hSemaphore, 1, &count);
    	}
    
    	return 0;
    }
    
    unsigned long __stdcall ThreadProc2(void* lp) {
    	long count;
    	while (number < 100) {
    		WaitForSingleObject(hSemaphore, INFINITE);	//等待信号量为有信号状态
    		cout << "thread 2 :"<<number << endl;
    		++number;
    		_sleep(100);
    		ReleaseSemaphore(hSemaphore, 1, &count);
    	}
    
    	return 0;
    }
    
    int main() {
    	hSemaphore = CreateSemaphore(NULL, 1, 100, "sema");
    	CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
    	CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);
    
    	Sleep(10*1000);
    	system("pause");
        return 0;
    }

运行结果：  
![这里写图片描述][aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwNzA1MjMwNjExNjAy]  
可以看到，实现了有序输出，实现了线程间同步。

### 【4】互斥量 ###

采用互斥对象机制。 只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以能保证公共资源不会同时被多个线程访问。互斥不仅能实现同一应用程序的公共资源安全共享，还能实现不同应用程序的公共资源安全共享。

代码示例：

#include "stdafx.h"
    #include<windows.h>
    #include<iostream>
    using namespace std;
    
    int number = 1;	//定义全局变量
    HANDLE hMutex;	//定义互斥对象句柄
    
    unsigned long __stdcall ThreadProc1(void* lp) {
    	while (number < 100) {
    		WaitForSingleObject(hMutex, INFINITE);
    		cout << "thread 1 :"<<number << endl;
    		++number;
    		_sleep(100);
    		ReleaseMutex(hMutex);
    	}
    
    	return 0;
    }
    
    unsigned long __stdcall ThreadProc2(void* lp) {
    	while (number < 100) {
    		WaitForSingleObject(hMutex, INFINITE);
    		cout << "thread 2 :"<<number << endl;
    		++number;
    		_sleep(100);
    		ReleaseMutex(hMutex);
    	}
    
    	return 0;
    }
    
    int main() {
    	hMutex = CreateMutex(NULL, false, "mutex");		//创建互斥对象
    	CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
    	CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);
    
    	Sleep(10*1000);
    	system("pause");
        return 0;
    }

运行结果：  
![这里写图片描述][aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwNzA1MjI1NjU0NDIy]  
可以看到，实现了有序输出，实现了线程同步。

[aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwNzA1MjIyODI3OTkz]: /images/20230208/ae5f8ce76e7844d2ad3178b174520679.png
[aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwNzA1MjI0ODI2Mjcy]: /images/20230208/d5635883fad949d5b38145455ef05dec.png
[aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwNzA1MjIzNzQ0NDk0]: /images/20230208/85504a9a6a584c28be22556cb63cac89.png
[aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwNzA1MjMwNjExNjAy]: /images/20230208/aacf7227d84c4cbbb7f868ba4f68e3bb.png
[aHR0cDovL2ltZy5ibG9nLmNzZG4ubmV0LzIwMTcwNzA1MjI1NjU0NDIy]: /images/20230208/1d75597a54d440c1b78d35f9e3d22f43.png