线程同步的几种方式

码成行

已于 2024-09-02 11:30:06 修改

阅读量984

点赞数 30

文章标签： c++

于 2024-08-23 09:40:23 首次发布

本文链接：https://blog.csdn.net/Minotaur3/article/details/141432905

版权

线程同步

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

线程同步是指线程之间所具有的一种制约关系，一个线程的执行依赖另一个线程的消息，当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒

线程互斥是指对于共享的数据或资源，在各线程访问时的排它性。当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源

在Windows中，同步机制主要有：事件(Event)、信号量(semaphore)、互斥体(mutex)、临界区(Critical section)

事件

事件(Event)是Windows提供的最灵活的线程间同步方式，事件可以处于激发状态(signaled or true)或未激发状态(unsignal or false)

根据状态变迁方式的不同，事件可分为两类：

1、手动设置：这种对象只可能用程序手动设置，在需要该事件或者事件发生时，采用SetEvent及ResetEvent来进行设置

2、自动恢复：一旦事件发生并被处理后，自动恢复到没有事件状态，不需要再次设置

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

#include <iostream>
#include <windows.h>
using namespace std;
int g_count = 1;
HANDLE hEvent;
DWORD WINAPI ThreadProcl(LPVOID lp) {
	while (g_count < 100) {
		WaitForSingleObject(hEvent, INFINITE);
		cout << "ThradProc1:" << g_count << endl;
		++g_count;
		SetEvent(hEvent);
		Sleep(70);
	}
	return 0;
}
DWORD WINAPI ThreadProc2(LPVOID lp) {
	while (g_count < 100) {
		WaitForSingleObject(hEvent, INFINITE);
		cout << "ThradProc2:" << g_count << endl;
		++g_count;
		SetEvent(hEvent);
		Sleep(70);
	}
	return 0;
}
int main() {
	hEvent = CreateEvent(NULL, FALSE, TRUE, L"testevent001");
	HANDLE hThread1 = CreateThread(NULL, 0, ThreadProcl, NULL, 0, NULL);
	HANDLE hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);
	WaitForSingleObject(hThread1, INFINITE);
	WaitForSingleObject(hThread2, INFINITE);
}

主函数中，CreateEvent创建事件对象，第二个参数false，表示自动恢复，第三个参数true，表示事件对象初始化状态为激发状态
然后创建两个线程，先等待到事件对象为激发状态的线程，继续往下执行，同时将事件
状态切换为未激发状态，别的线程继续等待，当前线程SetEvent，将事件对象切换为激发状态，等待的线程就可以继续执行这样保障了同一时间，只有一个线程在写共享资源g_count

信号量

信号量是维护0到指定最大值之间的同步对象

信号量状态在其计数大于0时是有信号的，其计数是0时是无信号的

信号量对象在控制上可以支持有限数量共享资源的访问

信号量的特点和用途：

1、如果当前资源的数量大于0，则信号量有效

2、如果当前资源数量是0，则信号量无效

3、系统决不允许当前资源的数量为负值

4、当前资源数量决不能大于最大资源数量

信号量API接口

HANDLE CreateSemaphore(
	LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,//信号量属性，参数作废，基本用NULL
	LONG lInitialCount,//初始化信号量数量，每碰到一次WaitFor…时，数量减1，当为0时产生阻塞
	LONG lMaxximumCount,//信号量的量大值
	PCTSTR lpName);// 命名
HANDLE OpenSemaphore(
	DWORD fdwAccess,//信号量对象的访问权限
	BOOL bInheritHandle,//句柄是否可以被子进程继承
	PCTSTR pszName//信号量的名称
);
BOOL ReleaseSemaphore(
	HANDLE hSemaphore,//要增加的信号量句柄
	LONG lReleaseCount,//要释放的数量，一般完成一个等待后调用此函数释放一个信号量，使得信号量平衡
	LPLONG lpPreviousCount);//释放前原来信号量的数量，可以设置为NULL （在设置信号量次数之前，目前还剩余的计数值）

#include <iostream>
#include <windows.h>
using namespace std;
int g_count = 1;
HANDLE hSemaphore;
DWORD WINAPI ThreadProc1(LPVOID lp) {
	long count;
	while(g_count < 100){
		WaitForSingleObject(hSemaphore, INFINITE);
		cout << "ThreadProcl:" << g_count << endl;
		++g_count;
		ReleaseSemaphore(hSemaphore, 1, &count);
		Sleep(70);
}
	return 0;
}
DWORD WINAPI ThreadProc2(LPVOID lp) {
	long count;
	while (g_count < 100) {
		WaitForSingleObject(hSemaphore, INFINITE);
		cout << "ThreadProc2:" << g_count << endl;
		++g_count;
		ReleaseSemaphore(hSemaphore, 1, &count);
		Sleep(70);
	}
	return 0;
}
int main() {
	hSemaphore = CreateSemaphore(NULL, 1, 100, L"Semaphore1l1");
	HANDLE hThreadl = CreateThread(NULL,0,ThreadProc1,NULL,0,NULL);
	HANDLE hThread2 = CreateThread(NULL,0,ThreadProc2,NULL,0,NULL);
	WaitForSingleObject(hThreadl, INFINITE);
	WaitForSingleObject(hThread2, INFINITE);
	return 0;
}

主函数中创建信号量对象，初始化只有一个信号量，创建两个线程，线程函数中WaitForSingleObject判断信号量，不是0，就捕获一个信号量，信号量数量减1，完成对共享资源的读写后，ReleaseSemaphore释放一个信号量，排队等待的线程就可以捕获该信号量，执行对应的线程函数

互斥量

互斥量，采用互斥对象机制，只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以能保证公共资源不会同时被多个线程访问

互斥不仅能实现同一应用程序的公共资源安全共享，还能实现不同应用程序的公共资源安全共享

windows互斥体：

#include <iostream>
#include <windows.h>
using namespace std;
int g_count = 1;
HANDLE hMutex;
DWORD WINAPI ThreadProcl(LPVOID lp) {
	while (g_count < 100) {
		WaitForSingleObject(hMutex, INFINITE);
		cout << "ThradProc1:" << g_count << endl;
		++g_count;
		ReleaseMutex(hMutex);
		Sleep(70);
	}
	return 0;
}
DWORD WINAPI ThreadProc2(LPVOID lp) {
	while (g_count < 100) {
		WaitForSingleObject(hMutex, INFINITE);
		cout << "ThradProc2:" << g_count << endl;
		++g_count;
		ReleaseMutex(hMutex);
		Sleep(70);
	}
	return 0;
}
int main() {
	hMutex = CreateMutex(NULL, FALSE,L"Mutex0001");
	HANDLE hThread1 = CreateThread(NULL,0, ThreadProcl,NULL,0,NULL);
	HANDLE hThread2 = CreateThread(NULL,0, ThreadProc2,NULL,0,NULL);
	WaitForSingleObject(hThread1,INFINITE);
	WaitForSingleObject(hThread2,INFINITE);
	return 0;
}

WaitForSingleObject等待互斥对象是未被拥有状态时，则拥有该互斥对象，线程结束阻塞，往后执行，处理结束后，ReleaseMutex再释放该互斥对象，互斥对象恢复未被拥有状态，其他线程可以获取它

stl互斥体：

在test函数内部，在读写共享资源g_count之前，获取锁，别的线程只能等待，确保同一时间只能一个线程读写该资源，处理完之后，释放锁，别的线程可以获取锁，从而读写共享资源

#include <iostream>
#include <windows.h>
#include <mutex>
using namespace std;
int g_count = 0;
mutex g_mutex; 
void test(const string& name) {
	for (int i = 0; i < 30;++i) {
		g_mutex.lock();
		++g_count;
		cout << name << " " << g_count << endl;
		g_mutex.unlock();
		Sleep(100);
	}
}
int main() {
	thread t1(test,"线程1");
	thread t2(test,"线程2");
	t1.join();
	t2.join();
	return 0;
}

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

临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的

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

#include <iostream>
#include <windows.h>
#include <mutex>
using namespace std;
int g_count = 1;
CRITICAL_SECTION hCriticaL;
DWORD WINAPI ThreadProc1(LPVOID lp) {
	while(g_count < 100){
	EnterCriticalSection(&hCriticaL);
	cout << "ThreadProcl:" << g_count << endl;
	++g_count;
	LeaveCriticalSection(&hCriticaL);
	Sleep(70);
}
	return 0;
}
DWORD WINAPI ThreadProc2(LPVOID lp) {
	while (g_count < 100) {
		EnterCriticalSection(&hCriticaL);
		cout << "ThreadProc2:" << g_count << endl;
		++g_count;
		LeaveCriticalSection(&hCriticaL);
		Sleep(70);
	}
	return 0;
}
int main() {
	InitializeCriticalSection(&hCriticaL);
	HANDLE hThreadl = CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
	HANDLE hThread2 = CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);
	WaitForSingleObject(hThreadl, INFINITE);
	WaitForSingleObject(hThread2, INFINITE);
	return 0;
	return 0;
}