c++线程同步

最新推荐文章于 2024-07-14 23:08:29 发布
最新推荐文章于 2024-07-14 23:08:29 发布
阅读量1.9k 收藏 19
点赞数 1
分类专栏： win32 多线程 C/C++基础
原文链接：https://blog.csdn.net/s_lisheng/article/details/74278765
版权
C/C++基础 同时被 3 个专栏收录
164 篇文章 4 订阅
订阅专栏
多线程
25 篇文章 3 订阅
订阅专栏
win32
6 篇文章 0 订阅
订阅专栏

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

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

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

#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;
}

结果：
在这里插入图片描述
可以看到有时两个线程计算的值相同，不是我们想要的结果。

二、关于线程同步

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

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

线程互斥是指对于共享的操作系统资源（指的是广义的”资源”，而不是Windows的.res文件，譬如全局变量就是一种共享资源），在各线程访问时的排它性。当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源。

线程互斥是一种特殊的线程同步。实际上，互斥和同步对应着线程间通信发生的两种情况：
1.当有多个线程访问共享资源而不使资源被破坏时；
2.当一个线程需要将某个任务已经完成的情况通知另外一个或多个线程时。

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

1.用户模式中线程的同步方法主要有原子访问和临界区等方法。其特点是同步速度特别快，适合于对线程运行速度有严格要求的场合。

2.内核对象的线程同步则主要由事件、等待定时器、信号量以及信号灯等内核对象构成。由于这种同步机制使用了内核对象，使用时必须将线程从用户模式切换到内核模式，而这种转换一般要耗费近千个CPU周期，因此同步速度较慢，但在适用性上却要远优于用户模式的线程同步方式。

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

三、Win32中的四种同步方式

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

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

#include<windows.h>
#include<iostream>
using namespace std;

int number = 1;

CRITICAL_SECTION critisection;//定义临界区句柄

unsigned long __stdcall ThreadProc1(void* lp)
{
	while (number < 100) 
	{
		EnterCriticalSection(&critisection);
		cout << "thread 1 :" << number << endl;
		++number;
		Sleep(100);
		LeaveCriticalSection(&critisection);
	}

	return 0;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
	while (number < 100) 
	{
		EnterCriticalSection(&critisection);//初始化临界区对象
		cout << "thread 2 :" << number << endl;
		++number;
		Sleep(100);
		LeaveCriticalSection(&critisection);
	}

	return 0;
}

int main() 
{
	InitializeCriticalSection(&critisection);
	CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);
	CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);

	Sleep(10 * 1000);

	system("pause");
	return 0;
}

结果:
在这里插入图片描述
可以看到，也实现了有序输出，实现了线程同步。
【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<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;
}

结果：
在这里插入图片描述
可以看到，实现了有序输出，实现了线程同步。

【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<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;
}

结果:
在这里插入图片描述
可以看到，实现了有序输出，实现了线程间同步。
【4】互斥量
采用互斥对象机制。 只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以能保证公共资源不会同时被多个线程访问。互斥不仅能实现同一应用程序的公共资源安全共享，还能实现不同应用程序的公共资源安全共享。
代码实现:

#include<windows.h>
#include<iostream>
using namespace std;

int number = 1;

HANDLE hMutex;	//定义互斥对象句柄

unsigned long __stdcall ThreadProc1(void* lp)
{
	long count;
	while (number < 100) 
	{
		WaitForSingleObject(hMutex, INFINITE);
		cout << "thread 1 :" << number << endl;
		++number;
		Sleep(100);
		ReleaseMutex(hMutex);
	}

	return 0;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
	long count;
	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;
}

结果:
在这里插入图片描述

可以看到，实现了有序输出，实现了线程间同步。

转载于:https://blog.csdn.net/s_lisheng/article/details/74278765

发如雪-ty
关注
  • 1
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++实现线程同步的几种方式
m0_74282605的博客
10-14 1274
在C++中，通过构造std::mutex的实例来创建互斥元，可通过调用其成员函数lock()和unlock()来实现加锁和解锁，然后这是不推荐的做法，因为这要求程序员在离开函数的每条代码路径上都调用unlock()，包括由于异常所导致的在内。3.LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection)，该函数的作用是使调用该函数的线程离开临界区并释放对该临界区的所有权，以便让其他线程也获得访问该共享资源的机会。该函数将在用户指定的事件对象上等待。
C++ 使用CMutex 类实现线程同步
05-21
vC++编写的 使用CMutex 类实现线程同步，可以和vc++深入详解结合起来学习
当在多线程环境中使用 C++进行编程时，怎样确保线程安全以及如何处理线程之间的同步和通信？
最新发布
xy520521的博客
07-14 328
C++标准库提供了一些线程安全的容器，如std::mutex、std::condition_variable和std::atomic等。资源管理：确保资源的正确管理和释放也是确保线程安全性的重要一部分。原子操作：原子操作是无法被中断的操作，可以保证操作的完整性。锁粒度：选择适当的锁粒度可以提高并发性能。如果只有一小部分代码需要互斥访问，可以将锁的范围减小到最小，以允许更多的线程同时执行。总的来说，确保线程安全性和处理线程之间的同步和通信需要综合考虑多种技术和技巧，根据具体的需求和情况选择合适的方法。
C++之线程同步
u010378559的博客
07-07 710
线程同步总结
C++ 线程 线程同步
langwang122的博客
01-04 2295
当多个线程或者进程同时访问公共资源的时候就需要同步。比如说一个线程准备访问堆上的一块内存，另外的一个线程把他给释放了但是还没有来得及设置为空，那么就会出现问题，这个时候就应该线程同步，比如让第一个线程判空访问完了，第二个线程在释放置空；或者让第二个线程释放置空完了，第一个线程在进行判空访问。 简单的说线程同步就是将原本在同一时间访问同一资源的线程，让他们有时间顺序的访问资源，即确保公共资源不被同...
C++多线程编程——线程同步（保姆级-1.4W字）
qq_25218501的博客
08-25 1307
线程同步是一种编程技术，它用于在多线程环境中确保多个线程能够正确、安全地共享和访问共享资源。线程同步的主要目的是防止数据竞争和不一致性，以及避免多个线程同时对同一数据进行修改或访问导致的问题。
C++ 线程同步
SJLin
08-17 807
一. 实现线程同步的方式 1. 临界区 临界区（Critical Section）是一段独占对某些共享资源访问的代码，在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。 2. 事件（CEve...
C++线程同步实例分析
12-31
本文实例分析了C++线程同步问题，分享给大家供大家参考。具体分析如下： 该实例设置全局变量g_bContinue，在主线程中设置全局变量g_bContinue，工作线程检测该全局变量，实现主线程控制工作线程的目的。 打印出的g_...
C++ 线程（串行 并行 同步 异步）详解
08-30
C++ 线程（串行 并行 同步 异步）详解 C++ 线程是指在程序中可以同时执行多个任务的技术，通过线程可以提高程序的执行效率和响应速度。在 C++ 中，线程可以分为串行线程和并行线程两种。 串行线程（Serial Thread...
c++ 线程同步类功能性封装
11-24
SyncEvent类可能包含初始化、设置、重置、等待等方法，提供对C++线程事件的封装。 - **semaphore.h**：这个文件可能定义了Semaphore类，提供了对信号量的操作接口，如构造函数、P操作和V操作的封装。 5. **应用...
visual studio C++线程同步
10-07
visual studio C++线程同步
C++线程同步的方法
钟离默的个人博客
05-18 1833
线程同步 线程之间通信的两个基本问题是互斥和同步。 线程同步是指线程之间所具有的一种制约关系，一个线程的执行依赖另一个线程的消息，当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒。 线程互斥是指对于共享的操作系统资源在各线程访问时的排它性。当有若干个线程都要使用某一共享资源时，任何时刻最多只允许一个线程去使用，其它要使用该资源的线程必须等待，直到占用资源者释放该资源。 线程互斥是一种特...
C++线程同步
gaoZhuanMing的博客
09-10 1302
C++ 标准库提供了如下线程同步机制： 互斥量（支持超时加锁、递归加锁） 读写锁（共享互斥量，也支持超时加锁） 互斥量包装器（基于 RAII 的思想） 条件变量 信号量（二元信号量、计数信号量） 栅栏（支持重用） 调用一次 1. 互斥量 #include <mutex> mutex：提供基础的互斥功能。 std::mutex mtx; mtx.lock(); // locks the mutex, blocks if the mutex is not available
多线程--线程同步
mitesi的专栏
06-08 846
线程的同步 Critical section（临界区）用来实现“排他性占有”。适用范围是单一进程的各线程之间。它是： ·         一个局部性对象，不是一个核心对象。 ·         快速而有效率。 ·         不能够同时有一个以上的critical section被等待。 ·         无法侦测是否已被某个线程放弃。 Mutex
C++多线程同步
书山有路勤为径
03-22 5134
摘要：本文介绍了C++11中如何开启新线程，并详细讲解了线程的基础同步原语：mutex, lock_guard, unique_lock, condition variable和semaphore等。如何采用async, packaged_task和promise实现future同步机制？怎样处理spurious wakeup?本文以质数判定服务为例为大家分享C++多线程同步措施！ 1. C++线程和基础同步原语 Thread mutex, lock_guard, unique_lock con.
c++线程：同步
onj123的博客
01-18 102
多线程共享进程资源，并发执行。对于同一资源，当某个线程访问时，其它线程就不可以访问，只能等到该线程不再使用时才可以访问。 同步： 临界资源访问的可控时序性（一个线程完另一个线程才可以操作） 互斥： 对临界资源同一时间的唯一访问性（保护临界资源安全） 方式 1. 互斥锁：简单 2. 读写锁：适用于读的次数大于写的次数 3. 信号量：适用于同步 4. 自旋锁：不推荐 5. 条件变量：不推荐 互斥锁 ...
C++多线程——线程同步
xuanyin235的专栏
08-29 847
线程同步一般有三种实现方法：互斥对象(CreateMutex)，事件对象(CreateEvent)，关键代码段(CriticalSection)，下面分别进行介绍 一、互斥对象(CreateMutex) 创建互斥 HANDLE CreateMutex( LPSECURITY_ATTRIBUTESlpMutexAttributes, // 指向安全属性的指针，NULL表示默认安全性 BOOLb
c++ 线程同步与异步
05-17
C++ 中的线程同步和异步通常是通过多线程编程来实现的。 线程同步是指多个线程之间协同工作，以共同完成一项任务。在同步模式下，线程之间会相互通信，以确保它们在执行任务时保持同步。常见的同步机制包括互斥锁、条件变量、信号量等。 互斥锁是一种常用的同步机制，它用于保护共享资源不被多个线程同时访问。当一个线程占用了互斥锁，其他线程就无法访问该共享资源，直到该线程释放锁。 条件变量是一种同步机制，它允许线程在共享资源达到某种状态时才能继续执行。当线程发现共享资源的状态不符合要求时，它将进入等待状态，直到其他线程改变了共享资源的状态。 信号量是一种同步机制，它用于控制多个线程对共享资源的访问。信号量的值表示共享资源的可用数量。当一个线程需要访问共享资源时，它必须先获得一个信号量，如果信号量的值为零，线程将进入等待状态。 线程异步是指多个线程之间相互独立地执行任务，不需要进行协同工作。在异步模式下，每个线程都可以独立地执行任务，不需要等待其他线程的输入或输出结果。常见的异步机制包括消息队列、事件驱动等。 消息队列是一种异步机制，它用于在多个线程之间传递消息。当一个线程需要向另一个线程发送消息时，它将消息写入消息队列，该线程将在适当的时候读取该消息。 事件驱动是一种异步机制，它用于响应外部事件的发生。当事件发生时，系统将通知相应的线程进行处理，而不需要等待其他线程的输入或输出结果。 总之，线程同步和异步都是多线程编程中的重要概念，程序员需要根据具体的应用场景来选择合适的同步或异步机制。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值