【效率对比】c++多线程同步几种方式的效率对比研究： 原子操作，c++锁，自旋锁，windows临界区，windows互斥对象

最新推荐文章于 2024-06-06 23:12:37 发布
最新推荐文章于 2024-06-06 23:12:37 发布
阅读量2.8k 收藏 12
点赞数 5
分类专栏： C++ 编程 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/carlclouder/article/details/104861333
版权
编程 同时被 3 个专栏收录
16 篇文章 0 订阅
订阅专栏
C++
9 篇文章 0 订阅
订阅专栏
源码
5 篇文章 0 订阅
订阅专栏

通过比较以下几种同步方式，测试各方法效率，分为以下6种情况做对比：

  1. 不加任何同步措施；
  2. Windows原子操作；
  3. c++11 mutrex；
  4. 自定义的自旋锁CLCS；
  5. Windows临界区；
  6. Windows互斥对象；

硬件平台：AMD 8核16线程，内存16GB
系统/软件平台：windows10，vs2019com(vc++)；
方法：定义3个变量，在多线程中自加（16线程x10万次），记录时间并考察结果正确性；

结果如下：
在这里插入图片描述
结论 ：

  1. 不加锁，速度极快，但结果是不可预测的错误值，没有应用价值。
  2. windows原子操作 及 c++11中的mutrex效率非常高；
    【让人不可思议的是，c++的mutrex锁的实现效率非常高，接近了原子操作的效率，这一点非常让人意外，一直以为c++锁会由于跨平台要求和底层调用封装，而会慢于windows临界区，看来这是不
    对的。通过查看mutrex在windows vc 上面的底层实现，发现原来是使用了windows7才加入 SRWLock锁（读写锁），也就是在windows vista及以前的windwos平台仍然使用的临界区，而windows7平台用SRWLock锁替代了，而进一步剖析SRWLock的底层实现，仍然是用的原子自旋锁，这也解释了为什么c++mutrex在win7及以上的平台效率和原子锁效率相同的原因】
  3. 自定义的自旋锁，速度可以实现得很精简，效率略高于Windows临界区的效率，毕竟摆脱了一些多余的调用过程；
  4. Windows临界区效率尚可，但仍然是原子操作和c++锁的所需时间的10倍以上；
  5. Windows互斥对象，由于实现跨进程同步，需要进入系统内核进行调度，所以比较慢，耗时是临界区的10倍以上；

以下是测试代码：
【 并行化支持】

int main() {	
	const size_t times = 100000;
	size_t a = 0, b = 0, c = 0;
	CLAtomic<size_t> aa = 0, ba = 0, ca = 0; //原子对象
	CLCS cs;
	CLCSLock cs2;
	TaskPoolStatic volatile as;
	CLTick tk; //高精度定时器
	tk.timingStart();
	parallel_proc([&](int ci, int n) {  //并行化
		for (size_t i = 0; i < times; i++)
		{
			++a; ++b; ++c;
		}
		});
	auto s0_ = tk.getSpendTime();
	cout << "\nno lock:       " << a << " , " << b << " , " << c << " , time = " << s0_ << " , error ...";
	tk.timingStart();
	parallel_proc([&](int ci, int n) {
		for (size_t i = 0; i < times; i++)
		{
			++aa;++ba;++ca;
		}
		});
	auto s0 = tk.getSpendTime();
	cout << "\nAtomic:        " << aa() << " , " << ba() << " , " << ca() << " , time = " << s0;
	a = 0, b = 0, c = 0;
	mutex cs3;
	tk.timingStart();
	parallel_proc([&](int ci, int n) {
		for (size_t i = 0; i < times; i++)
		{
			cs3.lock(); ++a; cs3.unlock();
			cs3.lock(); ++b; cs3.unlock();
			cs3.lock(); ++c; cs3.unlock();
		}
		});
	auto s4 = tk.getSpendTime();
	cout << "\nc++11 mutex:   " << a << " , " << b << " , " << c << " , time = " << s4;
	a = 0, b = 0, c = 0;
	tk.timingStart();
	parallel_proc([&](int ci, int n) {
		for (size_t i = 0; i < times; i++)
		{
			cs.lock(); ++a; cs.unlock();
			cs.lock(); ++b; cs.unlock();
			cs.lock(); ++c; cs.unlock();
		}
		});
	auto s1 = tk.getSpendTime();
	cout << "\nclcs:          " << a << " , " << b << " , " << c << " , time = " << s1;
	a = 0, b = 0, c = 0;
	tk.timingStart();
	parallel_proc([&](int ci, int n) {
		for (size_t i = 0; i < times; i++)
		{
			cs2.lock(); ++a; cs2.unlock();
			cs2.lock(); ++b; cs2.unlock();
			cs2.lock(); ++c; cs2.unlock();
		}
		});
	auto s2 = tk.getSpendTime();
	cout << "\nWindows cs:    " << a << " , " << b << " , " << c << " , time = " << s2;
	a = 0, b = 0, c = 0;
	HANDLE mt = CreateMutex(0, 0, 0);
	tk.timingStart();
	parallel_proc([&](int ci, int n) {
		for (size_t i = 0; i < times; i++)
		{
			if (WaitForSingleObject(mt, INFINITE) == WAIT_OBJECT_0) { ++a; ReleaseMutex(mt); }
			if (WaitForSingleObject(mt, INFINITE) == WAIT_OBJECT_0) { ++b; ReleaseMutex(mt); }
			if (WaitForSingleObject(mt, INFINITE) == WAIT_OBJECT_0) { ++c; ReleaseMutex(mt); }
		}
		});	
	auto s3 = tk.getSpendTime();
	CloseHandle(mt);
	cout << "\nWindows Mutex: " << a << " , " << b << " , " << c << " , time = " << s3;
	
	return 1;
	}

自旋锁定义：

#ifndef _CL_CS_H_
#define _CL_CS_H_
//自旋锁
typedef struct _cl_cs {
	LONG bLock = FALSE;
	DWORD ownerThreadId = 0;
	LONG lockCounts = 0;
	void enter() {
		auto cid = GetCurrentThreadId();
		if (ownerThreadId != cid) {
			while (InterlockedExchange(&bLock, TRUE) == TRUE);
			//Sleep(0);
			ownerThreadId = cid;
		}
		++lockCounts;
	}
	void leave() {
		auto cid = GetCurrentThreadId();
		if (cid != ownerThreadId)
			return;
		--lockCounts;
		if (lockCounts == 0) {
			ownerThreadId = 0;
			bLock = FALSE;
		}
	}
	inline void lock() { enter(); }
	inline void unlock() { leave(); }
}CLCS, * PCLCS;
#endif

原子模板类定义：

//原子操作类
#ifndef _CL_ATOMIC_H_
#define _CL_ATOMIC_H_
//默认状态下CLAtomic类对象的原子操作模式是否启动，原子操作在保证线程安全情况下将降低代码效率；
#define CLAtomic_bUseAtomc_def true

//原子操作类（模板）
template<class T>
class CLAtomic {	
protected:
	T Target;
	bool bUseAtomc;

	inline static bool atomicCAS(CHAR volatile* dest, CHAR newvalue, CHAR oldvalue)
	{
		SHORT cov = *reinterpret_cast<SHORT volatile*>(dest);cov &= 0xff00;
		SHORT new1 = newvalue;new1 |= cov;
		SHORT old = oldvalue;old |= cov;
		SHORT tem = InterlockedCompareExchange16(reinterpret_cast<SHORT volatile*>(dest),new1,old);
		return tem == old ? true : false;
	}
	inline static bool atomicCAS(UCHAR volatile* dest, UCHAR newvalue, UCHAR oldvalue)
	{
		return atomicCAS(reinterpret_cast<CHAR volatile*>(dest), CHAR(newvalue), CHAR(oldvalue));
	}
	inline static bool atomicCAS(SHORT volatile* dest, SHORT newvalue, SHORT oldvalue)
	{
		return InterlockedCompareExchange16(dest, newvalue, oldvalue) == oldvalue ? true : false;
	}
	inline static bool atomicCAS(USHORT volatile* dest, USHORT newvalue, USHORT oldvalue)
	{
		return atomicCAS(reinterpret_cast<SHORT volatile*>(dest), SHORT(newvalue), SHORT(oldvalue));
	}
	inline static bool atomicCAS(INT volatile* dest, INT newvalue, INT oldvalue)
	{
		return InterlockedCompareExchange((LONG volatile*)dest, (LONG)newvalue, (LONG)oldvalue) == (LONG)oldvalue ? true : false;
	}
	inline static bool atomicCAS(UINT volatile* dest, UINT newvalue, UINT oldvalue)
	{
		return atomicCAS(reinterpret_cast<INT volatile*>(dest), INT(newvalue), INT(oldvalue));
	}
	inline static bool atomicCAS(LONG volatile* dest, LONG newvalue, LONG oldvalue)
	{
		return InterlockedCompareExchange(dest, newvalue, oldvalue) == oldvalue ? true : false;
	}
	inline static bool atomicCAS(ULONG volatile* dest, ULONG newvalue, ULONG oldvalue)
	{
		return atomicCAS(reinterpret_cast<LONG volatile*>(dest), LONG(newvalue), LONG(oldvalue));
	}
	inline static bool atomicCAS(LONG64 volatile* dest, LONG64 newvalue, LONG64 oldvalue)
	{
		return InterlockedCompareExchange64(dest,newvalue,oldvalue) == oldvalue ? true : false;
	}
	inline static bool atomicCAS(ULONG64 volatile* dest, ULONG64 newvalue, ULONG64 oldvalue)
	{
		return atomicCAS(reinterpret_cast<LONG64 volatile*>(dest), LONG64(newvalue), LONG64(oldvalue));
	}
	inline static bool atomicCAS(FLOAT volatile* dest, FLOAT newvalue, FLOAT oldvalue)
	{
		//auto& new1 = *(LONG*)(void*)&newvalue;
		auto old1 = *(LONG*)(void*)&oldvalue;
		return InterlockedCompareExchange(
			reinterpret_cast<LONG volatile*>(dest),
			*(LONG*)(void*)&newvalue,
			old1) == old1 ? true : false;
	}
	inline static bool atomicCAS(DOUBLE volatile* dest, DOUBLE newvalue, DOUBLE oldvalue)
	{
		//auto& new1 = *(LONG64*)(void*)&newvalue;
		auto old1 = *(LONG64*)(void*)&oldvalue;
		return InterlockedCompareExchange64(
			reinterpret_cast<LONG64 volatile*>(dest),
			*(LONG64*)(void*)&newvalue,
			old1) == old1 ? true : false;
	}
	inline T increment()
	{
		T old;
		do {
			old = Target;
		} while (!CLAtomic::atomicCAS(&Target, old + T(1), old));
		return old;
	}
	inline T decrement()
	{
		T old;
		do {
			old = Target;
		} while (!CLAtomic::atomicCAS(&Target, old - T(1), old));
		return old;
	}
	inline T add(T v)
	{
		T old;
		do {
			old = Target;
		} while (!CLAtomic::atomicCAS(&Target, old + v, old));
		return old;
	}
	inline T mul(T v)
	{
		T old;
		do {
			old = Target;
		} while (!CLAtomic::atomicCAS(&Target, old * v, old));
		return old;
	}
	inline T div(T v)
	{
		T old;
		do {
			old = Target;
		} while (!CLAtomic::atomicCAS(&Target, old / v, old));
		return old;
	}
public:
	inline CLAtomic():bUseAtomc(CLAtomic_bUseAtomc_def){
	}
	inline CLAtomic(T v, bool _bUseAtomc = CLAtomic_bUseAtomc_def)
		:Target(v), bUseAtomc(_bUseAtomc) {
	}
	inline CLAtomic(const CLAtomic& v)
		:Target(v.Target), bUseAtomc(v.bUseAtomc) {
	}
	template<class T2>
	inline CLAtomic(const CLAtomic<T2>& v)
		:Target(v()), bUseAtomc(v.isUseAtomic()) {
	}
	CLAtomic& setUseAtomic(bool _bUseAtomc = CLAtomic_bUseAtomc_def) {
		return bUseAtomc = _bUseAtomc,*this;
	}
	bool isUseAtomic() const {
		return bUseAtomc;
	}
	template<class T2>
	inline CLAtomic& operator=(const T2 v2) {
		return Target = v2, *this;
	}
	template<class T2>
	inline CLAtomic& operator=(const CLAtomic<T2>& v2) {
		return Target = v2(), *this;
	}
	inline CLAtomic& operator=(const CLAtomic& v2) {
		return Target = v2.Target, *this;
	}
	inline CLAtomic& operator=(const T& v2) {
		return Target = v2, *this;
	}
	//默认为原子操作++()，当setUseAtomic(false)时采用非原子操作方式；
	inline CLAtomic& operator++() {
		return bUseAtomc ? increment() : ++Target, * this;
	}
	//默认为原子操作--()，当setUseAtomic(false)时采用非原子操作方式；
	inline CLAtomic& operator--() {
		return bUseAtomc ? decrement() : --Target, * this;
	}
	//默认为原子操作()++，当setUseAtomic(false)时采用非原子操作方式；
	inline T operator++(int) {
		if (bUseAtomc) {
			return increment();
		}
		else {
			T old = Target;  
			++Target;
			return old;
		}
	}
	//默认为原子操作()--，当setUseAtomic(false)时采用非原子操作方式；
	inline T operator--(int) {
		if (bUseAtomc) {
			return decrement();
		}
		else {
			T old = Target;  
			--Target;
			return old;
		}
	}
	//默认为原子操作+=，当setUseAtomic(false)时采用非原子操作方式；
	inline CLAtomic& operator+=(T v) {
		return  bUseAtomc ? add(v) : Target += v, * this;
	}
	//默认为原子操作-=，当setUseAtomic(false)时采用非原子操作方式；
	inline CLAtomic& operator-=(T v) {
		return  bUseAtomc ? add(0 - v) : Target -= v, * this;
	}
	//默认为原子操作*=，当setUseAtomic(false)时采用非原子操作方式；
	inline CLAtomic& operator*=(T v) {
		return  bUseAtomc ? mul(v) : Target *= v, * this;
	}
	//默认为原子操作/=，当setUseAtomic(false)时采用非原子操作方式；
	inline CLAtomic& operator/=(T v) {
		return  bUseAtomc ? div(v) : Target /= v, * this;
	}
	//默认为原子操作%=，当setUseAtomic(false)时采用非原子操作方式；
	inline  CLAtomic& operator%=(int v) {
		T old;
		do {
			old = Target;
		} while (!CLAtomic::atomicCAS(&Target, T(int(old) % v), old));
		return *this;
	}
	inline operator T() { return Target; }
	inline T operator()() const { return Target; }
	template<class T2> inline operator T2() const { return (T2)Target; }
	template<class T2> inline T operator+(const T2 v) const { return Target + v; }
	template<class T2> inline T operator-(const T2 v) const { return Target - v; }
	template<class T2> inline T operator*(const T2 v) const { return Target * v; }
	template<class T2> inline T operator/(const T2 v) const { return Target / v; }
	template<class T2> inline T operator%(const T2 v) const { return Target % (int)v; }
};

template<class T,class T2> inline T operator+(const T v,const CLAtomic<T2>& tag){ 
	return v + tag(); 
}
template<class T,class T2> inline T operator-(const T v,const CLAtomic<T2>& tag){ 
	return v - tag(); 
}
template<class T,class T2> inline T operator*(const T v,const CLAtomic<T2>& tag){ 
	return v * tag(); 
}
template<class T,class T2> inline T operator/(const T v,const CLAtomic<T2>& tag){ 
	return v / tag(); 
}
template<class T,class T2> inline T operator%(const T v,const CLAtomic<T2>& tag){ 
	return v % (int)tag(); 
}
#endif

计时器定义：

#ifndef __CL_TICK_DEF__
#define __CL_TICK_DEF__
 //高精度计时器类
 class CLTick {
 protected:
	 LARGE_INTEGER lis;
	 LARGE_INTEGER lie;
	 LARGE_INTEGER Freg;
 public:
	 CLTick() { 
		 timingStart();
	 }
	 //开始计时
	 CLTick& timingStart() {
		 QueryPerformanceFrequency(&Freg);
		 QueryPerformanceCounter(&lis);
		 return *this;
	 }
	 //取得从计时开始到当前的时间
	 double getSpendTime(bool saveToStart = false) {
		 QueryPerformanceCounter(&lie);
		 double rt = double(lie.QuadPart - lis.QuadPart) / double(Freg.QuadPart);
		 if (saveToStart)lis = lie;
		 return rt;
	 }
 };
#endif
夜雨清狂
关注
  • 5
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
利用C++11原子量如何实现自旋锁详解
12-26
自旋锁是一种基础的同步原语，用于保障对共享数据的互斥访问。与互斥锁的相比，在获取锁失败的时候不会使得线程阻塞而是一直自旋尝试获取锁。当线程等待自旋锁的时候，CPU不能做其他事情，而是一直处于轮询忙等的...
C++多线程同步效率对比之临界区和原子锁
bodybo的专栏
10-21 1万+
多线程编程经常遇到数据同步问题，通常的做法就是
锁与原子操作CAS的底层实现
thunderLZM的博客
09-23 424
​对于服务器而言，锁发生的场景主要是在多线程或多进程，多任务的操作系统中，避免不了会共享一些资源，就会出现线程a，线程b或者进程a，进程b同时操作同一资源(临界区)的问题会产生无法预料的现象，副作用。所以需要加锁或者对数据进行原子操作。
C++11原子操作
最新发布
红军不怕远征难，万水千山只等闲
06-06 1328
C++原子操作提供了一种高效、安全的多线程数据访问方式，在性能和安全性方面具有显著优势。通过合理使用std::atomic类和内存序选项，开发者可以编写出高效、可靠的多线程程序。
C++ 多线程 (4) 互斥量（mutex）与锁（lock）
一抹烟霞的博客
05-31 2734
文章目录一、基本概念二、使用方法2.1 mutex.lock()，unlock()2.2 std::lock_guard类模板2.3.1 std::lock_guard的std::adopt_lock参数2.4 std::unique_lock函数模板2.4.1 unique_lock的第二个参数std::lock()函数模板三、死锁3.1 发生原因3.2 解决办法 一、基本概念 在多线程环境中，有多个线程竞争同一个公共资源，就很容易引发线程安全的问题。因此就需要引入锁的机制，来保证任意时候只有一个线程在访
C++11多线程之mutex等锁机制和atomic原子操作对比
热门推荐
懒得停下脚步
01-19 2万+
一.简介这里以mutex锁机制为例. mutex函数:是一套专门用于线程同步锁机制的函数. #include <mutex> using namespace std;atomic原子操作:是在新标准C++11，引入了原子操作的概念，并通过这个新的头文件提供了多种原子操作数据类型，例如，atomic_bool,atomic_int等等. #include <atomic>
C++原子操作和互斥锁性能（速度）对比
崔杰城的博客
11-29 2493
执行时间是0.541秒，是耗时最短的，但是由于没有用互斥方法保护，所以临界资源n的值不正确（正确的值应该为0）。这是因为自增、自减操作不是原子的，编译得到的汇编指令可能会对应多条指令。可以看到耗时为：5.261秒，n的值为0。编写测试demo，开启两个线程，对全局变量n分别进行自增、自减操作，计算执行时间。所以对于基本类型的临界资源，我们进行访问时可以用原子操作代替互斥锁，来提高性能。执行时间最长，但也能保持临界资源n的值正确。先说结论：原子操作性能（速度）强于互斥锁，下面用例子进行说明。
多线程锁详解之【原子操作】
qq492927689的博客
06-02 1014
原子操作，顾名思义它的操作具有原子性。所谓原子性就是指动作不可分割且独占数据读写。什么是操作不可分割？ 我们知道系统的线程数总是大于CPU数，系统其实是把这些线程对象放到了一个队列里面，然后轮流把这些线程对象放到CPU核心上，执行对象一部分的代码，周而复始，直至所有的线程代码执行完毕。由于CPU计算速度极快，肉眼上是看不出线程的轮流执行的，但事实上每一个线程对象，确实是轮流地，断断续续地执行，不是连续的。而线程对象这种断断续续执行的特性，我们称之为线程对象的动作是可分割。 既然原子性动作不可分割，那就说明原
C#多线程编程中的锁系统（四）：自旋锁
01-20
目录 一：基础 二：自旋锁示例 三：SpinLock 四：继续SpinLock 五：总结 一：基础 内核锁：基于内核对象构造的锁机制，就是通常说的内核构造模式...自旋锁：原子操作+自循环。通常说的用户构造模式。 线程不休眠，一直
用原子自旋读写锁代替互斥锁提高多线程访问公共资源效率
04-12
总的来说，原子自旋锁是多线程编程中一种优化同步的手段，尤其在处理短暂锁竞争的情况下。然而，选择哪种锁应该根据具体应用场景和系统负载来决定，以达到最优的性能和资源利用。正确理解和使用自旋锁，可以有效提高...
Delphi XE10.2.3多线程大量读和少量写公共资源时，用原子自旋读写锁代替互斥锁提高效率
04-12
对于一个高性能服务器在处理多数读取，少量写入的场景时，如果还是使用常规的互斥锁方式，显然就不明智了，这种读多写少的场景最适合使用读写锁方式，读取时不加锁，多线程并发读取，效率是最高的，要写入数据时堵塞...
C++互斥量、原子锁、自旋锁等比较
qccz123456的博客
08-01 1万+
现象： （1）单线程无锁速度最快，但应用场合受限； （2）多线程无锁速度第二快，但结果不对，未保护临界代码段； （3）多线程原子锁第三快，且结果正确； （4）多线程互斥量较慢，慢与原子锁近10倍，结果正确； （5）多线程自旋锁最慢，慢与原子锁30倍，结果正确。 结论：原子锁速度最快，互斥量和自旋锁都用保护多线程共享资源。        自旋锁是一种非阻塞锁，也就是说，如果某线程需要获...
C++多线程，计算程序运行时间，以微秒为单位
huamin1990的专栏
04-08 1627
#include "stdafx.h" #include <windows.h> #include <iostream> #include <chrono> #include <thread> using namespace std; int N = 10; void CopyImageData(unsigned char *dst, unsigned char *src, int size) { for (int i = 0; i &...
一次简单的Windows和Linux多线程效率测试
qq_42538017的博客
04-02 2182
一次简单的Windows和Linux多线程效率测试配置执行时间源代码其他 配置 参数 Windows Linux IDE msvc2015 g++ (GCC) 版本 14.0.25420.01 Update3 11.2.0 编译器 RELEASE x64 C++版本 c++11 c++20 执行时间 线程数 Windows Linux 10000 12647.3154ms 959.823ms 20000 44117.0524ms 1831.181ms
【算法】C程序的运行速度测试
慕雪华年的博客
04-24 1319
C语言程序的运行速度测试more上提到了一点，即我们应该学会估计一个时间复杂度较高的算法，在机器上的运行速度。图简单大部分OJ题目，对C/C++代码的时间限制都是1s。所以我们测试的目标也将放在1s上。
C/C++编程：计算cpp程序运行时间（ms）（单线程&&多线程）
OceanStar的博客
08-06 2856
需要c++11支持 #include <chrono> auto start = std::chrono::system_clock::now(); //do something auto end = std::chrono::system_clock::now(); auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start); std::cout << elapse
C++多线程教程（二）衡量线程执行时间
Xiaoqing的博客
03-06 3426
简介 在利用多线程实现加速之前，我先来讲一下衡量线程执行时间的常用方法。实现的基本思路就是用衡量函数对执行代表包括起来。 基本语法 #include<iostream> #include<thread> using namespace std; using namespace std::chrono; //增加引用空间 template&lt...
三种线程同步方式的比较
孟源的专栏
08-20 1911
1、互斥对象和事件对象属于内核对象，利用内核对象进行线程同步，速度比较慢，但是利用内核对象，可以在多个进程的多个线程之间进行线程同步。2、关键代码段是工作在用户方式下，同步速度比较快，但容易产生死锁，因为在等待进入关键代码段时，无法设定超时值。一般在进行多线程编程时，首选关键代码段，如果在一个mfc程序中使用，可以在一个类的构造函数中调用InitializeCriticalSection函数，在这
C++中 atomic和mutex的效率
koko_TT的博客
08-16 2506
01 引 由于“哪怕是对一个bool型变量的赋值和读取都不保证原子性“，所以在并发环境下，操作可能产生Data Race的变量需要认为的加以保护。 常用的措施 用互斥量mutex的包裹的临界区。 利用atomic方式，赋予其原子性。 那么这两种措施效率如何呢？ 02 比对结果 mutex互斥量 time: 1.76376e+06 5000000 atomic形式 time: 3082...
详细介绍多线程加锁有三种方式：互斥锁、读写锁和自旋锁。
04-08
好的，我可以回答这个问题。多线程加锁通常有三种方式：互斥锁、读写锁和自旋锁。互斥锁是一种最常用的锁，它可以确保同一时间只有一个线程可以访问共享资源。读写锁则可以允许多个线程同时读取共享资源，但是只允许一个线程进行写操作。自旋锁则是一种特殊的锁，它会在线程需要访问共享资源时进行忙等待，直到锁被释放为止。这三种锁的应用场景不同，需要根据实际情况选择合适的锁来保证程序的正确性和效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值