程序设计：C++11原子 写优先的读写锁（源码详解）

最新推荐文章于 2024-05-07 08:31:17 发布
最新推荐文章于 2024-05-07 08:31:17 发布
阅读量1.2k 收藏 19
点赞数 22
分类专栏： 程序员造轮子（我的可重用代码） 文章标签： C++11 原子操作 读写锁 写优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77171572/article/details/134472732
版权

初级代码游戏的专栏介绍与文章目录-CSDN博客

我的github：codetoys，所有代码都将会位于ctfc库中。已经放入库中我会指出在库中的位置。

这些代码大部分以Linux为目标但部分代码是纯C++的，可以在任何平台上使用。

github位置：codetoys/ctfc.git src/function/mymutex.h和mymutex1-3.h  

        这是对程序设计：信号量 写优先的读写互斥对象（完整源码 代码详解）-CSDN博客的原子对象版本，写原来那个版本的时候C++11尚未发布。

        关于写优先的读写互斥对象的原理可以参考上面的链接，但使用原子对象比使用信号量更简单，因为我采用的是简单锁加上自行判断的方式。

        本文不详细讲解原子对象，只强调这么几点：

  • 原子对象是面向CPU的，非常晦涩，实际上，我认为这部分的设计是失败的
  • 原子对象的全部功能没有一种CPU是完全实现的，所以，搞清楚也没什么用
  • 对结构的原子实现需要借助隐藏的变量，在Linux上（准确地说大概应该是g++的STL实现）这个隐藏的变量是放在进程的其它位置，而不是直接添加在结构里面，所以只能实现进程内互斥，无法实现跨进程互斥。而在windows上（实际是指VS的STL实现），我推测如果数据放在内存映射文件（相当于UNIX/LINUX的共享内存），是可以跨进程互斥的。
  • 就用最严格的简单互斥就行了，别给自己找麻烦

        鉴于以上几点，我用atomic_flag做互斥控制，其功能就是锁定/解锁，相当于进出一次信号量操作，而信号量里面数值处理在代码里实现。

        为什么一定要用原子来重新实现呢？因为原子的性能比信号量实在是快了太多了。

        相关技术点：

  • C++11的原子功能 头文件<atomic> 在CentOS上并非默认支持，需要安装额外的库
  • C++11的线程功能 头文件<thread> 比POSIX线程库简单太多了
  • atomic_flag 原子的bool，可以用来实现锁定和解锁
  • atomic_flag::test_and_set() 如果是false就设置为true，整个操作是原子的，前后加了锁，不可能被中断和乱序
  • atomic_flag::clear() 设置为false，整个操作也是原子的
  • this_thread::yield() 让出线程时间片。做循环判断时用这个比死循环省CPU、比sleep定时响应快（就是为了实现所谓“自旋锁”，重试等待）

        读写锁代码：

#include <atomic>
#include <thread>

		struct mySEM
		{
		public:
			atomic_flag flag{false};
			time_t ctime{ 0 };

			bool OnW{false};
			long R_count{ 0 };
			long W_wait{ 0 };

		private:
			bool _Lock()
			{
				//cout << (long)this << " _Lock ..." << endl;
				while (flag.test_and_set())
				{
					this_thread::yield();
				}
				//cout << (long)this << "_Lock down" << endl;
				return true;
			}
			bool _UnLock()
			{
				//cout << (long)this << "_Lock release" << endl;
				flag.clear();
				return true;
			}
		public:
			void init()
			{
				flag.clear();
				ctime = time(nullptr);
				OnW = false;
				R_count = 0;
				W_wait = 0;
			}
			bool RLock(bool no_wait)
			{
				_Lock();
				while (!(!OnW && 0 == W_wait))
				{
					_UnLock();
					if (no_wait)return false;
					this_thread::yield();
					_Lock();
				}
				++R_count;
				_UnLock();
				return true;
			}
			bool RUnLock()
			{
				_Lock();
				--R_count;
				_UnLock();
				return true;
			}
			bool WLock(bool no_wait)
			{
				_Lock();
				++W_wait;
				_UnLock();
				
				_Lock();
				while (!(!OnW && 0 == R_count))
				{
					if (no_wait)
					{
						--W_wait;
						_UnLock();
						return false;
					}
					_UnLock();
					this_thread::yield();
					_Lock();
				}
				OnW = true;
				--W_wait;
				_UnLock();
				return true;
			}
			bool WUnLock()
			{
				_Lock();
				OnW = false;
				_UnLock();
				return true;
			}
		};

        解释一下：

atomic_flag flag{false}; 原子对象，用来保护对其它成员变量的操作。

time_t ctime{ 0 }; 创建时间，对功能而言可以无视。

bool OnW{false}; 状态：是否写锁定中。

long R_count{ 0 }; 读计数。

long W_wait{ 0 }; 写等待。

        很容易看出来这个读写锁的逻辑和程序设计：信号量 写优先的读写互斥对象（完整源码 代码详解）-CSDN博客中用信号量的逻辑是一样的。

        私有方法：

bool _Lock()/bool _UnLock() 锁定/解锁原子对象，公有方法必须先锁定才能操作内部成员。

        公有方法：

void init() 初始化，简单测试不需要使用，因为和初值是一样的。

bool RLock(bool no_wait)/bool RUnLock() 读锁定/解锁

bool WLock(bool no_wait)/bool WUnLock() 写锁定/解锁

        感觉比信号量简单多了啊。

        当然实际使用还要考虑如何跟踪调试，所以这个类其实只是实际代码一小部分而已，完整代码如下：

#pragma once

#include <atomic>
#include <thread>


	//对象实例不可复制不可移动，内部记录进程操作状态和线程操作状态
	class CZS_RWMutex2
	{
	public:
		struct mySEM
		{
		public:
			atomic_flag flag{false};
			time_t ctime{ 0 };

			bool OnW{false};
			long R_count{ 0 };
			long W_wait{ 0 };

		private:
			bool _Lock()
			{
				//cout << (long)this << " _Lock ..." << endl;
				while (flag.test_and_set())
				{
					this_thread::yield();
				}
				//cout << (long)this << "_Lock down" << endl;
				return true;
			}
			bool _UnLock()
			{
				//cout << (long)this << "_Lock release" << endl;
				flag.clear();
				return true;
			}
		public:
			void init()
			{
				flag.clear();
				ctime = time(nullptr);
				OnW = false;
				R_count = 0;
				W_wait = 0;
			}
			bool RLock(bool no_wait)
			{
				_Lock();
				while (!(!OnW && 0 == W_wait))
				{
					_UnLock();
					if (no_wait)return false;
					this_thread::yield();
					_Lock();
				}
				++R_count;
				_UnLock();
				return true;
			}
			bool RUnLock()
			{
				_Lock();
				--R_count;
				_UnLock();
				return true;
			}
			bool WLock(bool no_wait)
			{
				_Lock();
				++W_wait;
				_UnLock();
				
				_Lock();
				while (!(!OnW && 0 == R_count))
				{
					if (no_wait)
					{
						--W_wait;
						_UnLock();
						return false;
					}
					_UnLock();
					this_thread::yield();
					_Lock();
				}
				OnW = true;
				--W_wait;
				_UnLock();
				return true;
			}
			bool WUnLock()
			{
				_Lock();
				OnW = false;
				_UnLock();
				return true;
			}
		};
	private:
		mutable mySEM* sem_id{ nullptr };//信号量ID
		mutable bool isIngore{ false };//是否忽略，不锁定
		mutable bool isSafe{ false };//是否带有安全检查，确保操作序列正确

		//进程操作计数，防止操作顺序错误
		mutable atomic<int> count_WLock{ 0 };
		mutable atomic<int> count_RLock{ 0 };

		//线程操作记录，防止线程操作错误并可用于中途让出再重新锁定
		struct thread_data
		{
			bool _isLocked{ false };//是否已经锁定，若已经锁定则不重复锁定
			bool _isWLock{ false };//是否是写锁定，当isLocked时有效

			bool isLocked()const
			{
				return _isLocked;
			}
			bool isWLocked()const
			{
				return _isLocked && _isWLock;
			}
			bool isRLocked()const
			{
				return _isLocked && !_isWLock;
			}
			void thread_data_WLock()
			{
				_isLocked = true;
				_isWLock = true;
			}
			void thread_data_RLock()
			{
				_isLocked = true;
				_isWLock = false;
			}
			void thread_data_UnLock()
			{
				_isLocked = false;
				_isWLock = false;
			}
		};
	public:
		thread_data* getThreadData()const
		{
			thread_local map<CZS_RWMutex2 const*, thread_data > d;//通过对象地址区分不同的对象
			return &d[this];
		}

		//禁止移动和复制（不能用于vector，因为vector会移动对象）
		CZS_RWMutex2() = default;
		CZS_RWMutex2(CZS_RWMutex2 const&) = delete;
		CZS_RWMutex2& operator =(CZS_RWMutex2 const&) = delete;
		CZS_RWMutex2(CZS_RWMutex2 const&&) = delete;
		CZS_RWMutex2& operator =(CZS_RWMutex2 const&&) = delete;

		~CZS_RWMutex2()
		{
			if (0 != count_WLock || 0 != count_RLock)
			{
				if (0 != count_WLock) cout << "警告：析构而未解锁：" << sem_id << " is w locked " << count_WLock << endl;
				if (0 != count_RLock) cout << "警告：析构而未解锁：" << sem_id << " is r locked " << count_RLock << endl;
			}
			sem_id = nullptr;
		}
	private:
		mutable int m_errid{ 0 };//最近的错误号
		mutable CZS_StringStream m_errmsg;//最近的错误信息

		string errno2str()const
		{
			string s;
			switch (errno)
			{
			case EACCES: s = "EACCES"; break;
			case EINVAL: s = "EINVAL"; break;
			case EPERM: s = "EPERM"; break;
			case EOVERFLOW: s = "EOVERFLOW"; break;
			case ERANGE: s = "ERANGE"; break;
			case E2BIG: s = "E2BIG"; break;
			case EAGAIN: s = "EAGAIN"; break;
			case EFAULT: s = "EFAULT"; break;
			case EFBIG: s = "EFBIG"; break;
			case EIDRM: s = "EIDRM"; break;
			case EINTR: s = "EINTR"; break;
			case ENOSPC: s = "ENOSPC"; break;
			default: s = "semctl error";
			}
			return s;
		}
	public:
		string Report()const
		{
			char buf[1024];
			string ret;
			if (nullptr != sem_id)
			{
				sprintf(buf, "sem_id = %10ld , W %d R %d (%s), %s %s", (long)sem_id, count_WLock.load(), count_RLock.load()
					, (getThreadData()->isLocked() ? (getThreadData()->isWLocked() ? "W" : "R") : "-")
					, (isSafe ? "safe" : ""), (isIngore ? " , ingored" : ""));
				ret += buf;

				long w, w_count, r_count, w_wait;
				if (GetCount2(w, w_count, r_count, w_wait))
				{
					sprintf(buf, " 写锁 %ld 写计数 %ld 读计数 %ld 写等待 %ld", w, w_count, r_count, w_wait);
					ret += buf;
				}
				if (0 != m_errid)
				{
					sprintf(buf, " 错误：%d %s", m_errid, m_errmsg.str().c_str());
				}
				else
				{
					sprintf(buf, " 无错误");
				}
				ret += buf;
			}
			else
			{
				ret += "空信号量";
			}
			return ret;
		}
	private:
		void after_WLock()const
		{
			++count_WLock;
			getThreadData()->thread_data_WLock();
		}
		void after_RLock()const
		{
			++count_RLock;
			getThreadData()->thread_data_RLock();
		}
		void after_WUnLock()const
		{
			--count_WLock;
			getThreadData()->thread_data_UnLock();
		}
		void after_RUnLock()const
		{
			--count_RLock;
			getThreadData()->thread_data_UnLock();
		}
	public:
		//忽略锁定调用，不执行锁定
		void ingore()const { isIngore = true; }
		//恢复功能
		void enable()const { isIngore = false; }
		//启用安全检查
		void safe(bool _safe)const { isSafe = _safe; }
		bool isConnected()const { return nullptr != sem_id; }
		bool Attach(mySEM* id)
		{
			if (isSafe)
			{
				if (0 != count_WLock || 0 != count_RLock)
				{
					*(int*)&m_errid = __LINE__;
					(*(stringstream*)&m_errmsg).str("");
					*(stringstream*)&m_errmsg << "sem " << sem_id << " 已经锁定，需要先解锁";
					return false;
				}
			}
			sem_id = id;

			return nullptr != sem_id;
		}
		bool Detach()
		{
			if (isSafe)
			{
				if (0 != count_WLock || 0 != count_RLock)
				{
					*(int*)&m_errid = __LINE__;
					(*(stringstream*)&m_errmsg).str("");
					*(stringstream*)&m_errmsg << "sem " << sem_id << " 已经锁定，需要先解锁";
					return false;
				}
			}
			sem_id = nullptr;
			return true;
		}

		//创建新信号量
		bool Create(mySEM * id)
		{
			if (isSafe)
			{
				if (0 != count_WLock || 0 != count_RLock)
				{
					*(int*)&m_errid = __LINE__;
					(*(stringstream*)&m_errmsg).str("");
					*(stringstream*)&m_errmsg << "sem " << sem_id << " 已经锁定，需要先解锁";
					return false;
				}
			}
			sem_id = id;
			if (nullptr == sem_id)
			{
				m_errid = __LINE__;
				m_errmsg.str("");
				m_errmsg << errno2str();
				return false;
			}
			sem_id->init();
			return true;
		}
		//复位
		bool Reset()
		{
			return Create(sem_id);
		}
		//删除信号量
		bool Destory()
		{
			if (isSafe)
			{
				if (0 != count_WLock || 0 != count_RLock)
				{
					*(int*)&m_errid = __LINE__;
					(*(stringstream*)&m_errmsg).str("");
					*(stringstream*)&m_errmsg << "sem " << sem_id << " 已经锁定，需要先解锁";
					return false;
				}
			}

			sem_id = nullptr;
			return true;
		}
		//锁定，等待
		bool RLock()const { return _RLock(false); }
		bool TryRLock()const { return _RLock(true); }
		bool _RLock(bool no_wait)const
		{
			if (isSafe)
			{
				if (getThreadData()->isLocked())
				{
					*(int*)&m_errid = __LINE__;
					(*(stringstream*)&m_errmsg).str("");
					*(stringstream*)&m_errmsg << "sem " << sem_id << " 已经锁定，不能重复锁定";
					return false;
				}
			}
			if (isIngore)
			{
				after_RLock();
				return true;//忽略锁定
			}
			if (sem_id->RLock(no_wait))
			{
				after_RLock();
				return true;
			}
			else
			{
				return false;
			}
		}
		bool WLock()const { return _WLock(false); }
		bool TryWLock()const { return _WLock(true); }
		bool _WLock(bool no_wait)const
		{
			if (isSafe)
			{
				if (getThreadData()->isLocked())
				{
					*(int*)&m_errid = __LINE__;
					(*(stringstream*)&m_errmsg).str("");
					*(stringstream*)&m_errmsg << "sem " << sem_id << " 已经锁定，需要先解锁";
					return false;
				}
			}
			if (isIngore)
			{
				after_WLock();
				return true;//忽略锁定
			}

			if (sem_id->WLock(no_wait))
			{
				after_WLock();
				return true;
			}
			else
			{
				return false;
			}
		}
		//解除锁定
		bool RUnLock()const
		{
			if (isSafe)
			{
				if (!getThreadData()->isRLocked())
				{
					*(int*)&m_errid = __LINE__;
					(*(stringstream*)&m_errmsg).str("");
					*(stringstream*)&m_errmsg << "sem " << sem_id << " 未锁定或不是读锁定";
					return false;
				}
			}
			if (isIngore)
			{
				after_RUnLock();
				return true;//忽略锁定
			}
			if (sem_id->RUnLock())
			{
				after_RUnLock();
				return true;
			}
			else
			{
				*(int*)&m_errid = __LINE__;
				(*(stringstream*)&m_errmsg).str("");
				*(stringstream*)&m_errmsg << errno2str();
				return false;
			}
		}
		bool WUnLock()const
		{
			if (isSafe)
			{
				if (!getThreadData()->isWLocked())
				{
					*(int*)&m_errid = __LINE__;
					(*(stringstream*)&m_errmsg).str("");
					*(stringstream*)&m_errmsg << "sem " << sem_id << " 未锁定或不是写锁定";
					return false;
				}
			}
			if (isIngore)
			{
				after_WUnLock();
				return true;//忽略锁定
			}
			if (sem_id->WUnLock())
			{
				after_WUnLock();
				return true;
			}
			else
			{
				*(int*)&m_errid = __LINE__;
				(*(stringstream*)&m_errmsg).str("");
				*(stringstream*)&m_errmsg << errno2str();
				return false;
			}
		}

		string GetErrorMessage()const { return m_errmsg.str(); }
		int GetErrorID()const { return m_errid; }//获得最新的错误ID
		bool isFree()const
		{
			bool ignored;
			long w_count;
			long r_count;
			long w_wait;
			if (GetCount(ignored, w_count, r_count, w_wait))
			{
				return 0 == w_count + r_count + w_wait;
			}
			return false;
		}
		bool GetCount(bool& ignored, long& w_count, long& r_count, long& w_wait)const
		{
			long w;
			ignored = isIngore;
			return GetCount2(w, w_count, r_count, w_wait);
		}
		bool GetCount2(long& w, long& w_count, long& r_count, long& w_wait)const
		{
			w = 0;
			w_count = 0;
			r_count = 0;
			w_wait = 0;
			if (nullptr != sem_id)
			{
				w = !sem_id->OnW;
				w_count = sem_id->OnW;
				r_count = sem_id->R_count;
				w_wait = sem_id->W_wait;
			}
			return true;
		}
	};

        这部分主要是加入了跟踪调试的功能，具体解释在这里：

        程序设计：C++11原子 写优先的读写锁（源码详解二：操作跟踪）-CSDN博客

（这里是结束）

初级代码游戏
关注
  • 22
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 读写锁
03-13
完成对资源的读写同步功能，允许多个线程读资源，只允许一个线程修改资源。
无锁编程:c++11基于atomic实现共享读写锁(写优先)
10km的专栏
11-04 1万+
在多线程状态下，对一个对象的读写需要加锁，基于CAS指令原子语句可以实现高效的线程间协调。 以下代码实现了一个资源锁: readLock/Unlock 实现共享的读取锁，MAX_SHARE_COUNT用于限制同时读取的线程数， writeLock/Unlock 实现独占的写入锁,同时只允许一个线程写入，当写入线程执行时，所有的读取线程都被阻塞。 locck/unlock语句允许嵌套，
程序设计：C++11原子 写优先的读写锁（源码详解二：操作跟踪）
最新发布
编程之道在明明德在亲民在止于至善
05-07 1108
程序设计：C++11原子 写优先的读写锁（源码详解二：操作跟踪）
C++11 实现读写锁 read_write_mutex
描绘自己的王国……
09-12 5937
读写锁 read_write_mutex 对于一个数据操作，简单的分可以分为读和写。 但是经常会遇到多人同时访问一个数据的情况： 多人读 多人写 有人读，有人写 处理这种情况，常用的方式是加锁（Mutex）： 读与读之间，允许并发。 读与写，写与写之间互斥。 所以读写锁需要支持以上两种情况。 读写锁 // file: read_write_mutex.h #pragma once #in...
读写锁 C++11
weixin_57722445的博客
07-12 187
【代码】读写锁 C++11。
c++11 实现读写锁
Peace
11-25 7198
Note: C++ 17里已经引进了读写锁 std::shared_mutex , 其lock()即以写方式加锁， 其lock_shared()即以读方式加锁。https://en.cppreference.com/w/cpp/thread/shared_mutex 实现一个读写锁类， 可以有两种方式获取锁，读方式，写方式。 允许多个"读线程"同时进入临界区，但是同一时刻只允许一个"写线程"进入临界区。当有写线程进入临界区时，不允许任何其他读或写线程同时进入。 写线程优先。方法：在类中增加成...
c++ 11读写锁
qq_36583051的博客
11-17 3218
参考：C++中的RAII_一蓑烟雨任平生 也无风雨也无晴-CSDN博客 C++11实现模板化(通用化)RAII机制_10km的专栏-CSDN博客_c++11 raii 无锁编程:c++11基于atomic实现共享读写锁(写优先)_10km的专栏-CSDN博客 raii.h #include <type_traits> #include <functional> namespace gyd { /* 元模板，如果是const类型则去除const修饰符 */ templat
C++11线程中的几种锁
GoodLinGL的博客
04-26 7752
线程之间的锁有：互斥锁、条件锁、自旋锁、读写锁、递归锁。一般而言，锁的功能与性能成反比。不过我们一般不使用递归锁（C++标准库提供了std::recursive_mutex），所以这里就不推荐了。 互斥锁（Mutex） ...
详解C++11原子类型与原子操作
08-18
C++11原子类型与原子操作是C++11标准库中的一项重要特性，它提供了原子类型和原子操作的支持，帮助开发者轻松实现多线程程序中的原子操作。下面是C++11原子类型与原子操作的相关知识点： 1. 认识原子操作 原子操作...
内存读写驱动的源码(C++)
01-04
综上所述，内存读写驱动的源码(C++)涵盖了操作系统底层机制、驱动开发技术以及C++编程技巧等多个领域，对理解计算机系统的工作原理和提升系统性能有着重要价值。通过分析和学习这样的源码，开发者可以深入学习到硬件...
c++ 读写 Excel 表格 源码
11-20
c++ 读写 Excel 表格 附带源码
X64驱动读写内存源码
11-20
X64驱动是指专为64位操作系统设计的驱动程序，因为64位系统提供了更大的地址空间和更高的性能。在本案例中，我们讨论的是一份"X64驱动读写内存源码"，它涉及到驱动开发的关键技术，包括在Ring0层（内核模式）进行...
C++开发：为什么多线程读写shared_ptr要加锁的详细介绍
12-31
（shared_ptr）的引用计数本身是安全且无锁的，但对象的读写则不是，因为 shared_ptr 有两个数据成员，读写操作不能原子化。根据文档...
C++读写Excel的实现方法详解
12-31
1.导入Excel类型库使用Visual C++的扩展指令#import导入Excel类型库： 代码如下:#import “C:\\Program Files\\Common Files\\microsoft shared\\OFFICE14\\MSO.DLL” \ rename(“RGB”,”MsoRGB”) \ rename(...
C++多线程——读写锁shared_lock/shared_mutex
热门推荐
princeteng's blogs
01-13 2万+
主要参考APUE以及std::shared_mutex 1. 何为读写锁 相比互斥锁，读写锁允许更高的并行性，互斥量要么锁住状态要么不加锁，而且一次只有一个线程可以加锁。 读写锁可以有三种状态： 读模式加锁状态； 写模式加锁状态； 不加锁状态； 只有一个线程可以占有写模式的读写锁，但是可以有多个线程占有读模式的读写锁。 读写锁也叫做“共享-独占锁”，当读写锁以读模式锁住时，它是以共享模式锁住的...
c++ 并发-读写锁(shared_mutex,shared_lock)
weixin_44654161的博客
05-01 7649
目录 1.前言 2.正文 3.代码和验证 1.前言： 前几日上班时，因为底层逻辑修改。多线程情况下，许多函数如果依然按照原有的锁去串行执行，效率会很低。(原先是 std::mutex ，以及每个函数用的锁是std::lock_guard) 这时我的领导给我新任务，修改多线程的锁，在修改后，要求函数 1 函数2 要能并发执行，且前两者并发执行时与函数 3 函数4 函数5是互斥的。而函数 3，4，5与所有函数都互斥。(例如函数3运行的时候，函数1 2 4 5都是卡着等待函数3执行完毕再继续执行)。
c++11 thread中使用 读写锁
04-27
C11标准库中提供了读写锁，可以用来实现多个线程对同一资源的并发读写操作。下面是使用读写锁的示例代码： ```c #include <stdio.h> #include <stdlib.h> #include <threads.h> int data = 0; rwlock_t lock; int reader(void* arg) { int id = *(int*)arg; while (1) { thrd_sleep((struct timespec){.tv_sec = 1}, NULL); // 模拟读操作 // 加读锁 rwlock_rdlock(&lock); printf("Reader %d read data: %d\n", id, data); // 释放读锁 rwlock_unlock(&lock); } return 0; } int writer(void* arg) { int id = *(int*)arg; while (1) { thrd_sleep((struct timespec){.tv_sec = 2}, NULL); // 模拟写操作 // 加写锁 rwlock_wrlock(&lock); data++; printf("Writer %d write data: %d\n", id, data); // 释放写锁 rwlock_unlock(&lock); } return 0; } int main(int argc, char const *argv[]) { // 初始化读写锁 rwlock_init(&lock); // 创建3个读线程 thrd_t readers[3]; int readerIds[3]; for (int i = 0; i < 3; i++) { readerIds[i] = i + 1; thrd_create(&readers[i], reader, &readerIds[i]); } // 创建2个写线程 thrd_t writers[2]; int writerIds[2]; for (int i = 0; i < 2; i++) { writerIds[i] = i + 1; thrd_create(&writers[i], writer, &writerIds[i]); } // 等待所有线程结束 for (int i = 0; i < 3; i++) { thrd_join(readers[i], NULL); } for (int i = 0; i < 2; i++) { thrd_join(writers[i], NULL); } // 销毁读写锁 rwlock_destroy(&lock); return 0; } ``` 这个示例程序中有3个读线程和2个写线程，读线程每隔1秒钟读一次共享变量data的值，写线程每隔2秒钟写一次共享变量data的值。读线程和写线程之间会相互竞争读写锁，以实现对共享变量的并发访问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值