C++多线程编程（第三章 利用栈特性自动释放锁RALL，锁管理器、控制器）

已于 2023-09-08 08:04:34 修改
阅读量375 收藏 1
点赞数
分类专栏： C++ 多线程 文章标签： c++ 开发语言 多线程
于 2023-07-28 10:01:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42727069/article/details/131952450
版权

目录

1、什么是RALL，手动代码实现

RALL（resource Acquisition Is Initialization ）C++ 之父Bjarne Stroustrup 提出；
使用局部对象来管理资源的技术称为资源获取即初始化；它的生命周期是由操作系统来管理的，无需人工介入；资源的销毁容易忘记，造成死锁或者内存泄漏。

1.1、手动实现RALL管理mutex资源

RALL 编写代码方式，代码更简介，而且不会遗漏解锁

#include <thread>
#include <iostream>
#include <string>
#include <mutex>
#include <shared_mutex>

using namespace std;

//RALL
class XMutex
{
public:
	XMutex(mutex & mux):mux_(mux)//引用的时候赋值，在初始化的时候就记到成员变量中
	{//构造函数中加锁
		cout << "Lock" << endl;
		mux.lock();
	}

	~XMutex()
	{
		cout << "UnLock" << endl;
		mux_.unlock();
	}
private:
	mutex& mux_;//把初始化的锁存下来，引用

};

static mutex mux;
void TestMutex(int status )
{//业务逻辑
	XMutex lock(mux);
	if (status == 1)
	{
		cout << "=1" << endl;
		return;
	}
	else
	{
		cout << "!= 1" << endl;
		return;
	}
	return;
}

int main()
{
	TestMutex(1);
	TestMutex(2);
	return 0;

}

在这里插入图片描述

1.2、C++ 11 支持的RALL管理互斥资源lock_guard

C++ 11 实现严格基于作用域的互斥体所有权包装器；
adopt_lock C++11 类型为adopt_lock_t ,假设调用方已拥有互斥的所有权；
通过{}控制锁的临界区
在这里插入图片描述
举例了三种情形

#include <thread>
#include <iostream>
#include <string>
#include <mutex>
#include <shared_mutex>

using namespace std;


static mutex gmutex;
void TestLockGuard(int i)
{//错误用法示例：这样写会被第一个线程占用，不能出来
	lock_guard<mutex> lock(gmutex);
	for (;;)
	{
		cout << "In " << i << endl;
		this_thread::sleep_for(500ms);
	}

}

void TestLockGuard_Demo2(int i)
{//正确用法，用大括号来释放锁
	{
		lock_guard<mutex> lock(gmutex);
		cout << "Begin thread " << i << endl;
	}
	for (;;)
	{
		{
			lock_guard<mutex> lock(gmutex);
			cout << "In " << i << endl;
			this_thread::sleep_for(200ms);
		}
		this_thread::sleep_for(1ms);
	}

}

void TestLockGuard_Demo3(int i)
{//举例开头拥有锁的初始化情况

	gmutex.lock();
	{
		//开头已经用有锁
		//lock_guard<mutex>lock(gmutex);//这样写会报错，因为这个锁在外部已经锁住了，通过捕获异常可以进行分析；
		lock_guard<mutex>lock(gmutex,adopt_lock);//如果外部锁住了，这样写可以避免(调用了重载特性)，程序可以正常运行
		//解锁
	}


	{
		lock_guard<mutex> lock(gmutex);
		cout << "Begin thread " << i << endl;
	}
	for (;;)
	{
		{
			lock_guard<mutex> lock(gmutex);
			cout << "In " << i << endl;
			this_thread::sleep_for(200ms);
		}
		this_thread::sleep_for(1ms);
	}

}


int main()
{
	//printf("Demo1:\n");
	//for (int i = 0; i < 3; i++)
	//{
	//	thread th(TestLockGuard,i+1);
	//	th.detach();
	//}
	//getchar();


	//printf("Demo2:\n");
	//for (int i = 0; i < 3; i++)
	//{
	//	thread th(TestLockGuard_Demo2, i + 1);
	//	th.detach();
	//}
	//getchar();


	printf("Demo3:\n");
	for (int i = 0; i < 3; i++)
	{
		thread th(TestLockGuard_Demo3, i + 1);
		th.detach();
	}


	getchar();
	return 0;

}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

1.3、unique_lock C++ 11

unique_lock C++ 11实现可移动的互斥体所有权包装器
支持临时释放锁unlock
支持adopt_lock(已经用有锁，不加锁，出栈区会释放)
支持defer_lock(延后拥有，不加锁，出栈区不释放)
支持try_to_lock尝试获得互斥的所有权而不阻塞，获取失败退出栈区不会释放，通过owns_lock函数判断

#include <thread>
#include <iostream>
#include <string>
#include <mutex>
#include <shared_mutex>

using namespace std;


int main()
{
	{
		static mutex mux;
		{
			//第一种常规特性，与lock_guard使用方法一样，但是不一样的是，执行过程中可以临时释放锁，再加锁
			unique_lock<mutex>lock(mux);//
			lock.unlock();//但是unique_lock支持中间临时释放锁
			lock.lock();//加锁
		}//出栈释放锁


		{
			//第二个特性：已经用有锁，不锁定，退出解锁
			mux.lock();
			unique_lock<mutex>lock(mux,adopt_lock);//针对已经用有锁
		
		}
		{
			//第三个特性，延后加锁，不拥有，退出不解锁
			unique_lock<mutex>lock(mux,defer_lock);//延时锁，在后面再进行上锁
			lock.lock();//主动上锁，退出栈区解锁

		}
		{
			//mux.lock();//如果被锁定，后面也不会阻塞，不用有所
			//第四种特性，尝试加锁，不阻塞，失败不拥有锁
			unique_lock<mutex> lock(mux, try_to_lock);
			if (lock.owns_lock())
			{
				cout << "owns_lock" << endl;
			}
			else
			{
				cout << "not owns_lock" << endl;
			}
		
		}
	
	}
	getchar();

	return 0;

}

1.4、共享锁

共享锁，所有线程都可以进入访问
shared_lock C++ 14 ：C++14才有的特性
实现可移动的共享互斥体所有权封装器
使用方法：

#include <thread>
#include <iostream>
#include <string>
#include <mutex>
#include <shared_mutex>

using namespace std;


int main()
{
	{
		//共享锁
		static shared_timed_mutex tmux;
		//读取锁，共享锁，所有线程都可以同时读取
		{
			//调用共享锁
			shared_lock<shared_timed_mutex>lock(tmux);
			cout << "Read data" << endl;

		}//退出栈区释放构造，释放共享锁

		{
			//写入锁，互斥锁，否则会造成写入异常，
			unique_lock<shared_timed_mutex>lock(tmux);
			cout << "write data" << endl;


		}
	}


	getchar();

	return 0;

}

1.5、避免死锁（scoped_lock、lock）

方法一：scoped_lock C++17 ：scoped_lock C++17 用于多个互斥体的免死锁RAII封装器，类似lock
设置方法：
在这里插入图片描述
方法二：c++11 使用lock(mux1,mux2),同时锁定锁定mux1和mux2,不要分两行代码锁定。示例代码：

//要用到C++17,需要在属性->C++ ->语言 ->C++语言标注-> C++17
//先测试死锁情况，再看使用scoped_lock解决死锁情况


#include <thread>
#include <iostream>
#include <string>
#include <mutex>
#include <shared_mutex>

using namespace std;

static mutex mux1;
static mutex mux2;

void TestScope1()
{//死锁的测试代码
	this_thread::sleep_for(100ms);//模拟死锁，停100ms
	cout << "TestScope1 Begin mux1 lock" << endl;
	mux1.lock();
	cout << "TestScope1 Begin mux2 lock" << endl;
	mux2.lock();//死锁
	cout <<"In :TestScope1" << endl;
	this_thread::sleep_for(1000ms);
	mux1.unlock();
	mux2.unlock();
}
void TestScope2()
{//这个代码不变
	cout << "TestScope2 Begin mux2 lock" << endl;
	mux2.lock();
	this_thread::sleep_for(100ms);//模拟死锁，停100ms

	cout << "TestScope2 Begin mux1 lock" << endl;
	mux1.lock();//死锁
	cout << "In :TestScope2" << endl;

	this_thread::sleep_for(1500ms);
	mux2.unlock();
	mux1.unlock();
}


void TestScope1_C11()//C++11的解决方案
{
	this_thread::sleep_for(100ms);//模拟死锁，停100ms
	//cout << "TestScope1 Begin mux1 lock" << endl;
	//mux1.lock();
	//cout << "TestScope1 Begin mux2 lock" << endl;
	//mux2.lock();//死锁
	lock(mux1,mux2);//C++11的解决方案,两个同时锁住才能进行下一步操作，有一个没有锁住，则不进行下一步操作
	cout << "In :TestScope1" << endl;
	this_thread::sleep_for(1000ms);
	mux1.unlock();
	mux2.unlock();
}


void TestScope1_C17()//C++17的解决方案
{
	this_thread::sleep_for(100ms);//模拟死锁，停100ms
	//cout << "TestScope1 Begin mux1 lock" << endl;
	//mux1.lock();
	//cout << "TestScope1 Begin mux2 lock" << endl;
	//mux2.lock();//死锁
	//lock(mux1, mux2);//C++11的解决方案,两个同时锁住才能进行下一步操作，有一个没有锁住，则不进行下一步操作
	scoped_lock lock(mux1,mux2);//C++17的解决方案，必须要把属性设置为C++17才行

	cout << "In :TestScope1" << endl;
	this_thread::sleep_for(1000ms);
	//mux1.unlock();//C++17这种方法改后，这里不需要手动释放，否则会报错
	//mux2.unlock();
}



int main()
{
	{
		//printf("Demo1:演示死锁：\n");
		演示死锁
		//{
		//	thread th(TestScope1);
		//	th.detach();
		//}

		//printf("Demo2:演示C++11解决死锁方案：\n");
		//{//C++ 11的解决方案
		//	thread th(TestScope1_C11);
		//	th.detach();
		//}

		printf("Demo3:演示C++17解决死锁方案：\n");
		{//C++ 17的解决方案
			thread th(TestScope1_C17);
			th.detach();
		}


		{//下面代码不注释，不动
			thread th(TestScope2);
			th.detach();
		}
		
	}

	getchar();

	return 0;

}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

鸿儒517
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++编程规范50条规则
12-22
很久没有更新过博客了，其实不管多忙，有时候写写博客未尝不是一种提升。下面是我近看的一本书的部分内容。 　1.不要忽视警告，尽量没有警告。 　2.使用自动构建系统 　3.使用版本控制系统 　4.在代码审查上投入...
ReporAll图形报表设计器和Demo
04-17
**ReporAll图形报表设计器** 是一款专为IT专业人员设计的强大报表工具，它提供了直观的图形界面，使得用户能够轻松创建、编辑和管理各种复杂的报表。这款设计器以高效、灵活和用户友好著称，是数据可视化的重要工具...
C++ 自动释放锁
u013206135的专栏
01-19 763
#include <mutex> std::mutex mOperateMtx; int funtiontest() { lock_guard<mutex> lock(mOperateMtx); //handle ... return 0; }
用C++实现锁的自动释放
数据挖掘及搜索专栏
04-28 4001
我在做多核核多任务程序时，常遇到这样一个问题：为了互斥访问我会习惯性的手动加锁，但却老是养不成手动解锁的习惯，其实很多时候也不是自己养不成，主要是多核下任务量一多，复杂性就跟着起来，是不是的就给忘了，我能咋办呢？想来想去，也参考了一些资料，想到C++中不是有析构函数么？析构函数是可以自动被调用的，把锁的释放工作放到析构函数中去，这样不是可以自动完成锁的自动释放工作了，这是多么的完美！当然还有很多情
C++开发基础之浅谈多线程的锁机制
最新发布
dotnet研习社
05-07 1457
在C++中，多线程的锁机制是确保线程安全的重要组成部分。当多个线程需要访问共享资源时，锁可以防止同时访问，从而避免数据竞争和条件竞争。C++11及其之后的版本提供了多种锁机制，包括互斥锁（mutex）递归锁（recursive mutex）共享锁（shared mutex）和读写锁（read-write mutex）。互斥锁（std::mutex）std::mutex是最基本的锁类型，用于保护共享数据，确保同时只有一个线程可以访问该数据。使用lock和unlock方法或者和管理类来简化锁的管理。
C++11 自动释放锁
幻想之渔
08-30 4261
c++11加入了很多新的特性，值得我们去探索。 先看一个例子：普通的、不能自动的释放自己的锁 #include /*std::cout*/ #include /*std::thread*/ #include /*std::bind*/ #include /*usleep*/ #include /*std::mutex、 std::lock_guard*/ clas
C++ Rall机制
weixin_44850236的博客
10-13 186
RAII 是 resource acquisition is initialization 的缩写，意为“资源获取即初始化”。它是 C++ 之父 Bjarne Stroustrup 提出的设计理念，其核心是把资源和对象的生命周期绑定，对象创建获取资源，对象销毁释放资源。在 RAII 的指导下，C++ 把底层的资源管理问题提升到了对象生命周期管理的更高层次。c.在析构函数中执行销毁操作。d.使用时声明一个该对象的类。a.设计一个类封装资源。b.在构造函数中初始化。
定义一个函数结束后自动释放的锁
小水晶的专栏
07-06 690
#include class InterLock{public: InterLock() {  InitializeCriticalSection(&cs_); } ~InterLock() {  DeleteCriticalSection(&cs_); } void enter() {  EnterCriticalSection(&cs_)
v0.2开发文档1
08-08
例如，`MutexLockGuard`类就是一种典型的RAII实现，它在构造时获取锁（即对`pthread_mutex_t`的锁定），并在对象析构时自动释放锁。这种设计确保了在代码块执行完毕后，锁会被正确地解锁，即使在发生异常的情况下也...
comment-hunter-prototype：记录来自rall的注释中的关键字频率
02-12
Reddit Scraper原型 记录对注释中提到关键字的频率。 数据通过记录到数据库中。 安装 使用进行安装。 pip install 用法 首先，在Heroku上运行免费的dyno worker。...可以在data.json中找到搜索到的关键字列表。...
nat-choco-recipes:辛辛那提大学于2021年Spring进行的RALL3080巧克力和能量研究项目
04-06
在交互式监视模式下启动测试运行器。 有关更多信息，请参见关于的部分。 yarn build 构建生产到应用程序build文件夹。 它在生产模式下正确捆绑了React，并优化了构建以获得最佳性能。 生成被最小化，并且文件名...
C++ RALL机制详解
yyxyong的博客
07-25 1万+
RAII 是 resource acquisition is initialization 的缩写，意为“资源获取即初始化”。它是 C++ 之父 Bjarne Stroustrup 提出的设计理念，其核心是把资源和对象的生命周期绑定，对象创建获取资源，对象销毁释放资源。在 RAII 的指导下，C++ 把底层的资源管理问题提升到了对象生命周期管理的更高层次。 那么到底什么是 RALL 机制？使用 C+
C++ Rall机制详解
热门推荐
越努力越幸运—liupu
04-04 1万+
RAII 是 resource acquisition is initialization 的缩写，意为“资源获取即初始化”。它是 C++ 之父 Bjarne Stroustrup 提出的设计理念，其核心是把资源和对象的生命周期绑定，对象创建获取资源，对象销毁释放资源。在 RAII 的指导下，C++ 把底层的资源管理问题提升到了对象生命周期管理的更高层次。 那么到底什么是 RALL 机制
RALL
yx20130919的博客
06-28 1371
产生原因： 在C++中，如果在这个程序段结束时需要完成一些资源释放工作，那么正常情况下自然是没有什么问题，但是当一个异常抛出时，释放资源的语句就不会被执行。于是Bjarne Stroustrup就想到确保能运行资源释放代码的地方就是在这个程序段（栈帧）中放置的对象的析构函数了，因为stack winding会保证它们的析构函数都会被执行。 将初始化和资源释放都移动到一个包装类中的...
【c++基础】第五章 RALL机制与智能指针
distant_Rove666的博客
02-05 1367
第五章 RALL机制与智能指针
【具体使用实例】Rall封装线程（C\C++）
肥宅Sean
03-18 1098
局部对象就要被逆序销毁。 通过这个性质，创建一个RAII等待线程完成(RAII，Resource Acquisition Is Initialization)。 这里是通过一个类实现的。通过简单的封装之后，使用起来会比较方便。 这个核心的RALL封装的类代码如下： class ThreadGuard { thread&amp; t; public: explic...
C++ 智能指针——主要包括：《为什么需要智能指针》《RALL的使用原理》《auto，unique，share三者联系和区别，以及三者的实现》《RALL扩展训练》
dpfxaca6的博客
05-16 623
《一》为什么需要智能指针？ 在我们上一节课 异常 哪一节课的时候，我们知道了之前我们提到的问题，为下面的两个问题，我们还没有解决。 malloc出来的空间，没有进行释放，存在内存泄漏的问题。 异常安全问题。如果在malloc和free之间如果存在抛异常，那么还是有内存泄漏。这种问题就叫异常安全。 《二》智能指针的使用及原理 （2.1）RAII RAII（Resource Acquisition...
C++必知必会RALL与Pimpl
滴答滴答的迪迦的博客
09-24 996
RALL Pimpl惯用法
c++多线程之利用RALL技术写一个安全的临界区
FairLikeSnow的博客
06-18 441
CRITICAL_SECTION g_cs; class CMySafeLock { public: CMySafeLock(CRITICAL_SECTION *p) { m_pCS = p; cout << "----------------lock------------------\n"; EnterCriticalSection(m_pCS); } ~CMySafeLock() { LeaveCriticalSection(m_pCS); cout &lt
检查这段代码：#include <bits/stdc++.h> using namespace std; #define VMEM_N 320 random_device rd; mt19937 mt(rd()); vector<int> gen(){ auto rall=uniform_int_distribution(0,VMEM_N-1); vector<int> w; w.push_back(rall(mt)); for (int j=0;w.size()<320;){ w.push_back([&](){ if (j==0||j==2){ return w.back()+1; }else if (j==1&&0<w.back()-1){ return uniform_int_distribution(0,w.back()-1)(mt); }else if (j==3&&w.back()+1<VMEM_N-1){ return uniform_int_distribution(w.back()+1,VMEM_N-1)(mt); }else return rall(mt); }()%VMEM_N); if (++j>=4) j=0; } return w; }
06-06
这段代码定义了一个名为gen的函数，其返回值是一个长度为320的整数向量。该函数使用了随机数生成器mt19937和uniform_int_distribution来生成随机数。具体来说，该函数首先生成一个[0, VMEM_N-1]范围内的随机数，并将其作为向量的第一个元素。接下来，该函数使用了一个for循环来生成向量的其余319个元素。在生成每个元素时，该函数根据一个条件语句来选择使用哪种方式生成随机数。具体来说，当j等于0或2时，函数会生成上一个元素加1的数值；当j等于1时，函数会生成一个在0到上一个元素减1之间的随机数；当j等于3时，函数会生成一个在上一个元素加1到VMEM_N-1之间的随机数。最后，函数使用取模运算将生成的随机数限制在[0, VMEM_N-1]范围内，并将其添加到向量中。在生成每个元素后，函数还会更新j的值，以便下一次循环可以使用不同的生成方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值