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

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

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

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

    • 原子对象是面向CPU的，非常晦涩，实际上，我认为这部分的设计是失败的
    • 原子对象的全部功能没有一种CPU是完全实现的，所以，搞清楚也没什么用
    • 就用最严格的简单互斥就行了，别给自己找麻烦

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

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

            读写锁代码：

    1. #include 
    2. #include 
    3.  
    4. 		struct mySEM
    5. 		{
    6. 		public:
    7. 			atomic_flag flag{false};
    8. 			time_t ctime{ 0 };
    9.  
    10. 			bool OnW{false};
    11. 			long R_count{ 0 };
    12. 			long W_wait{ 0 };
    13.  
    14. 		private:
    15. 			bool _Lock()
    16. 			{
    17. 				//cout << (long)this << " _Lock ..." << endl;
    18. 				while (flag.test_and_set())
    19. 				{
    20. 					this_thread::yield();
    21. 				}
    22. 				//cout << (long)this << "_Lock down" << endl;
    23. 				return true;
    24. 			}
    25. 			bool _UnLock()
    26. 			{
    27. 				//cout << (long)this << "_Lock release" << endl;
    28. 				flag.clear();
    29. 				return true;
    30. 			}
    31. 		public:
    32. 			void init()
    33. 			{
    34. 				flag.clear();
    35. 				ctime = time(nullptr);
    36. 				OnW = false;
    37. 				R_count = 0;
    38. 				W_wait = 0;
    39. 			}
    40. 			bool RLock(bool no_wait)
    41. 			{
    42. 				_Lock();
    43. 				while (!(!OnW && 0 == W_wait))
    44. 				{
    45. 					_UnLock();
    46. 					if (no_wait)return false;
    47. 					this_thread::yield();
    48. 					_Lock();
    49. 				}
    50. 				++R_count;
    51. 				_UnLock();
    52. 				return true;
    53. 			}
    54. 			bool RUnLock()
    55. 			{
    56. 				_Lock();
    57. 				--R_count;
    58. 				_UnLock();
    59. 				return true;
    60. 			}
    61. 			bool WLock(bool no_wait)
    62. 			{
    63. 				_Lock();
    64. 				++W_wait;
    65. 				_UnLock();
    66. 				
    67. 				_Lock();
    68. 				while (!(!OnW && 0 == R_count))
    69. 				{
    70. 					if (no_wait)
    71. 					{
    72. 						--W_wait;
    73. 						_UnLock();
    74. 						return false;
    75. 					}
    76. 					_UnLock();
    77. 					this_thread::yield();
    78. 					_Lock();
    79. 				}
    80. 				OnW = true;
    81. 				--W_wait;
    82. 				_UnLock();
    83. 				return true;
    84. 			}
    85. 			bool WUnLock()
    86. 			{
    87. 				_Lock();
    88. 				OnW = false;
    89. 				_UnLock();
    90. 				return true;
    91. 			}
    92. 		};

            解释一下：

    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() 写锁定/解锁

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

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

    1. #pragma once
    2.  
    3. #include 
    4. #include 
    5.  
    6.  
    7. 	//对象实例不可复制不可移动，内部记录进程操作状态和线程操作状态
    8. 	class CZS_RWMutex2
    9. 	{
    10. 	public:
    11. 		struct mySEM
    12. 		{
    13. 		public:
    14. 			atomic_flag flag{false};
    15. 			time_t ctime{ 0 };
    16.  
    17. 			bool OnW{false};
    18. 			long R_count{ 0 };
    19. 			long W_wait{ 0 };
    20.  
    21. 		private:
    22. 			bool _Lock()
    23. 			{
    24. 				//cout << (long)this << " _Lock ..." << endl;
    25. 				while (flag.test_and_set())
    26. 				{
    27. 					this_thread::yield();
    28. 				}
    29. 				//cout << (long)this << "_Lock down" << endl;
    30. 				return true;
    31. 			}
    32. 			bool _UnLock()
    33. 			{
    34. 				//cout << (long)this << "_Lock release" << endl;
    35. 				flag.clear();
    36. 				return true;
    37. 			}
    38. 		public:
    39. 			void init()
    40. 			{
    41. 				flag.clear();
    42. 				ctime = time(nullptr);
    43. 				OnW = false;
    44. 				R_count = 0;
    45. 				W_wait = 0;
    46. 			}
    47. 			bool RLock(bool no_wait)
    48. 			{
    49. 				_Lock();
    50. 				while (!(!OnW && 0 == W_wait))
    51. 				{
    52. 					_UnLock();
    53. 					if (no_wait)return false;
    54. 					this_thread::yield();
    55. 					_Lock();
    56. 				}
    57. 				++R_count;
    58. 				_UnLock();
    59. 				return true;
    60. 			}
    61. 			bool RUnLock()
    62. 			{
    63. 				_Lock();
    64. 				--R_count;
    65. 				_UnLock();
    66. 				return true;
    67. 			}
    68. 			bool WLock(bool no_wait)
    69. 			{
    70. 				_Lock();
    71. 				++W_wait;
    72. 				_UnLock();
    73. 				
    74. 				_Lock();
    75. 				while (!(!OnW && 0 == R_count))
    76. 				{
    77. 					if (no_wait)
    78. 					{
    79. 						--W_wait;
    80. 						_UnLock();
    81. 						return false;
    82. 					}
    83. 					_UnLock();
    84. 					this_thread::yield();
    85. 					_Lock();
    86. 				}
    87. 				OnW = true;
    88. 				--W_wait;
    89. 				_UnLock();
    90. 				return true;
    91. 			}
    92. 			bool WUnLock()
    93. 			{
    94. 				_Lock();
    95. 				OnW = false;
    96. 				_UnLock();
    97. 				return true;
    98. 			}
    99. 		};
    100. 	private:
    101. 		mutable mySEM* sem_id{ nullptr };//信号量ID
    102. 		mutable bool isIngore{ false };//是否忽略，不锁定
    103. 		mutable bool isSafe{ false };//是否带有安全检查，确保操作序列正确
    104.  
    105. 		//进程操作计数，防止操作顺序错误
    106. 		mutable atomic<int> count_WLock{ 0 };
    107. 		mutable atomic<int> count_RLock{ 0 };
    108.  
    109. 		//线程操作记录，防止线程操作错误并可用于中途让出再重新锁定
    110. 		struct thread_data
    111. 		{
    112. 			bool _isLocked{ false };//是否已经锁定，若已经锁定则不重复锁定
    113. 			bool _isWLock{ false };//是否是写锁定，当isLocked时有效
    114.  
    115. 			bool isLocked()const
    116. 			{
    117. 				return _isLocked;
    118. 			}
    119. 			bool isWLocked()const
    120. 			{
    121. 				return _isLocked && _isWLock;
    122. 			}
    123. 			bool isRLocked()const
    124. 			{
    125. 				return _isLocked && !_isWLock;
    126. 			}
    127. 			void thread_data_WLock()
    128. 			{
    129. 				_isLocked = true;
    130. 				_isWLock = true;
    131. 			}
    132. 			void thread_data_RLock()
    133. 			{
    134. 				_isLocked = true;
    135. 				_isWLock = false;
    136. 			}
    137. 			void thread_data_UnLock()
    138. 			{
    139. 				_isLocked = false;
    140. 				_isWLock = false;
    141. 			}
    142. 		};
    143. 	public:
    144. 		thread_data* getThreadData()const
    145. 		{
    146. 			thread_local mapconst*, thread_data > d;//通过对象地址区分不同的对象
    147. 			return &d[this];
    148. 		}
    149.  
    150. 		//禁止移动和复制（不能用于vector，因为vector会移动对象）
    151. 		CZS_RWMutex2() = default;
    152. 		CZS_RWMutex2(CZS_RWMutex2 const&) = delete;
    153. 		CZS_RWMutex2& operator =(CZS_RWMutex2 const&) = delete;
    154. 		CZS_RWMutex2(CZS_RWMutex2 const&&) = delete;
    155. 		CZS_RWMutex2& operator =(CZS_RWMutex2 const&&) = delete;
    156.  
    157. 		~CZS_RWMutex2()
    158. 		{
    159. 			if (0 != count_WLock || 0 != count_RLock)
    160. 			{
    161. 				if (0 != count_WLock) cout << "警告：析构而未解锁：" << sem_id << " is w locked " << count_WLock << endl;
    162. 				if (0 != count_RLock) cout << "警告：析构而未解锁：" << sem_id << " is r locked " << count_RLock << endl;
    163. 			}
    164. 			sem_id = nullptr;
    165. 		}
    166. 	private:
    167. 		mutable int m_errid{ 0 };//最近的错误号
    168. 		mutable CZS_StringStream m_errmsg;//最近的错误信息
    169.  
    170. 		string errno2str()const
    171. 		{
    172. 			string s;
    173. 			switch (errno)
    174. 			{
    175. 			case EACCES: s = "EACCES"; break;
    176. 			case EINVAL: s = "EINVAL"; break;
    177. 			case EPERM: s = "EPERM"; break;
    178. 			case EOVERFLOW: s = "EOVERFLOW"; break;
    179. 			case ERANGE: s = "ERANGE"; break;
    180. 			case E2BIG: s = "E2BIG"; break;
    181. 			case EAGAIN: s = "EAGAIN"; break;
    182. 			case EFAULT: s = "EFAULT"; break;
    183. 			case EFBIG: s = "EFBIG"; break;
    184. 			case EIDRM: s = "EIDRM"; break;
    185. 			case EINTR: s = "EINTR"; break;
    186. 			case ENOSPC: s = "ENOSPC"; break;
    187. 			default: s = "semctl error";
    188. 			}
    189. 			return s;
    190. 		}
    191. 	public:
    192. 		string Report()const
    193. 		{
    194. 			char buf[1024];
    195. 			string ret;
    196. 			if (nullptr != sem_id)
    197. 			{
    198. 				sprintf(buf, "sem_id = %10ld , W %d R %d (%s), %s %s", (long)sem_id, count_WLock.load(), count_RLock.load()
    199. 					, (getThreadData()->isLocked() ? (getThreadData()->isWLocked() ? "W" : "R") : "-")
    200. 					, (isSafe ? "safe" : ""), (isIngore ? " , ingored" : ""));
    201. 				ret += buf;
    202.  
    203. 				long w, w_count, r_count, w_wait;
    204. 				if (GetCount2(w, w_count, r_count, w_wait))
    205. 				{
    206. 					sprintf(buf, " 写锁 %ld 写计数 %ld 读计数 %ld 写等待 %ld", w, w_count, r_count, w_wait);
    207. 					ret += buf;
    208. 				}
    209. 				if (0 != m_errid)
    210. 				{
    211. 					sprintf(buf, " 错误：%d %s", m_errid, m_errmsg.str().c_str());
    212. 				}
    213. 				else
    214. 				{
    215. 					sprintf(buf, " 无错误");
    216. 				}
    217. 				ret += buf;
    218. 			}
    219. 			else
    220. 			{
    221. 				ret += "空信号量";
    222. 			}
    223. 			return ret;
    224. 		}
    225. 	private:
    226. 		void after_WLock()const
    227. 		{
    228. 			++count_WLock;
    229. 			getThreadData()->thread_data_WLock();
    230. 		}
    231. 		void after_RLock()const
    232. 		{
    233. 			++count_RLock;
    234. 			getThreadData()->thread_data_RLock();
    235. 		}
    236. 		void after_WUnLock()const
    237. 		{
    238. 			--count_WLock;
    239. 			getThreadData()->thread_data_UnLock();
    240. 		}
    241. 		void after_RUnLock()const
    242. 		{
    243. 			--count_RLock;
    244. 			getThreadData()->thread_data_UnLock();
    245. 		}
    246. 	public:
    247. 		//忽略锁定调用，不执行锁定
    248. 		void ingore()const { isIngore = true; }
    249. 		//恢复功能
    250. 		void enable()const { isIngore = false; }
    251. 		//启用安全检查
    252. 		void safe(bool _safe)const { isSafe = _safe; }
    253. 		bool isConnected()const { return nullptr != sem_id; }
    254. 		bool Attach(mySEM* id)
    255. 		{
    256. 			if (isSafe)
    257. 			{
    258. 				if (0 != count_WLock || 0 != count_RLock)
    259. 				{
    260. 					*(int*)&m_errid = __LINE__;
    261. 					(*(stringstream*)&m_errmsg).str("");
    262. 					*(stringstream*)&m_errmsg << "sem " << sem_id << " 已经锁定，需要先解锁";
    263. 					return false;
    264. 				}
    265. 			}
    266. 			sem_id = id;
    267.  
    268. 			return nullptr != sem_id;
    269. 		}
    270. 		bool Detach()
    271. 		{
    272. 			if (isSafe)
    273. 			{
    274. 				if (0 != count_WLock || 0 != count_RLock)
    275. 				{
    276. 					*(int*)&m_errid = __LINE__;
    277. 					(*(stringstream*)&m_errmsg).str("");
    278. 					*(stringstream*)&m_errmsg << "sem " << sem_id << " 已经锁定，需要先解锁";
    279. 					return false;
    280. 				}
    281. 			}
    282. 			sem_id = nullptr;
    283. 			return true;
    284. 		}
    285.  
    286. 		//创建新信号量
    287. 		bool Create(mySEM * id)
    288. 		{
    289. 			if (isSafe)
    290. 			{
    291. 				if (0 != count_WLock || 0 != count_RLock)
    292. 				{
    293. 					*(int*)&m_errid = __LINE__;
    294. 					(*(stringstream*)&m_errmsg).str("");
    295. 					*(stringstream*)&m_errmsg << "sem " << sem_id << " 已经锁定，需要先解锁";
    296. 					return false;
    297. 				}
    298. 			}
    299. 			sem_id = id;
    300. 			if (nullptr == sem_id)
    301. 			{
    302. 				m_errid = __LINE__;
    303. 				m_errmsg.str("");
    304. 				m_errmsg << errno2str();
    305. 				return false;
    306. 			}
    307. 			sem_id->init();
    308. 			return true;
    309. 		}
    310. 		//复位
    311. 		bool Reset()
    312. 		{
    313. 			return Create(sem_id);
    314. 		}
    315. 		//删除信号量
    316. 		bool Destory()
    317. 		{
    318. 			if (isSafe)
    319. 			{
    320. 				if (0 != count_WLock || 0 != count_RLock)
    321. 				{
    322. 					*(int*)&m_errid = __LINE__;
    323. 					(*(stringstream*)&m_errmsg).str("");
    324. 					*(stringstream*)&m_errmsg << "sem " << sem_id << " 已经锁定，需要先解锁";
    325. 					return false;
    326. 				}
    327. 			}
    328.  
    329. 			sem_id = nullptr;
    330. 			return true;
    331. 		}
    332. 		//锁定，等待
    333. 		bool RLock()const { return _RLock(false); }
    334. 		bool TryRLock()const { return _RLock(true); }
    335. 		bool _RLock(bool no_wait)const
    336. 		{
    337. 			if (isSafe)
    338. 			{
    339. 				if (getThreadData()->isLocked())
    340. 				{
    341. 					*(int*)&m_errid = __LINE__;
    342. 					(*(stringstream*)&m_errmsg).str("");
    343. 					*(stringstream*)&m_errmsg << "sem " << sem_id << " 已经锁定，不能重复锁定";
    344. 					return false;
    345. 				}
    346. 			}
    347. 			if (isIngore)
    348. 			{
    349. 				after_RLock();
    350. 				return true;//忽略锁定
    351. 			}
    352. 			if (sem_id->RLock(no_wait))
    353. 			{
    354. 				after_RLock();
    355. 				return true;
    356. 			}
    357. 			else
    358. 			{
    359. 				return false;
    360. 			}
    361. 		}
    362. 		bool WLock()const { return _WLock(false); }
    363. 		bool TryWLock()const { return _WLock(true); }
    364. 		bool _WLock(bool no_wait)const
    365. 		{
    366. 			if (isSafe)
    367. 			{
    368. 				if (getThreadData()->isLocked())
    369. 				{
    370. 					*(int*)&m_errid = __LINE__;
    371. 					(*(stringstream*)&m_errmsg).str("");
    372. 					*(stringstream*)&m_errmsg << "sem " << sem_id << " 已经锁定，需要先解锁";
    373. 					return false;
    374. 				}
    375. 			}
    376. 			if (isIngore)
    377. 			{
    378. 				after_WLock();
    379. 				return true;//忽略锁定
    380. 			}
    381.  
    382. 			if (sem_id->WLock(no_wait))
    383. 			{
    384. 				after_WLock();
    385. 				return true;
    386. 			}
    387. 			else
    388. 			{
    389. 				return false;
    390. 			}
    391. 		}
    392. 		//解除锁定
    393. 		bool RUnLock()const
    394. 		{
    395. 			if (isSafe)
    396. 			{
    397. 				if (!getThreadData()->isRLocked())
    398. 				{
    399. 					*(int*)&m_errid = __LINE__;
    400. 					(*(stringstream*)&m_errmsg).str("");
    401. 					*(stringstream*)&m_errmsg << "sem " << sem_id << " 未锁定或不是读锁定";
    402. 					return false;
    403. 				}
    404. 			}
    405. 			if (isIngore)
    406. 			{
    407. 				after_RUnLock();
    408. 				return true;//忽略锁定
    409. 			}
    410. 			if (sem_id->RUnLock())
    411. 			{
    412. 				after_RUnLock();
    413. 				return true;
    414. 			}
    415. 			else
    416. 			{
    417. 				*(int*)&m_errid = __LINE__;
    418. 				(*(stringstream*)&m_errmsg).str("");
    419. 				*(stringstream*)&m_errmsg << errno2str();
    420. 				return false;
    421. 			}
    422. 		}
    423. 		bool WUnLock()const
    424. 		{
    425. 			if (isSafe)
    426. 			{
    427. 				if (!getThreadData()->isWLocked())
    428. 				{
    429. 					*(int*)&m_errid = __LINE__;
    430. 					(*(stringstream*)&m_errmsg).str("");
    431. 					*(stringstream*)&m_errmsg << "sem " << sem_id << " 未锁定或不是写锁定";
    432. 					return false;
    433. 				}
    434. 			}
    435. 			if (isIngore)
    436. 			{
    437. 				after_WUnLock();
    438. 				return true;//忽略锁定
    439. 			}
    440. 			if (sem_id->WUnLock())
    441. 			{
    442. 				after_WUnLock();
    443. 				return true;
    444. 			}
    445. 			else
    446. 			{
    447. 				*(int*)&m_errid = __LINE__;
    448. 				(*(stringstream*)&m_errmsg).str("");
    449. 				*(stringstream*)&m_errmsg << errno2str();
    450. 				return false;
    451. 			}
    452. 		}
    453.  
    454. 		string GetErrorMessage()const { return m_errmsg.str(); }
    455. 		int GetErrorID()const { return m_errid; }//获得最新的错误ID
    456. 		bool isFree()const
    457. 		{
    458. 			bool ignored;
    459. 			long w_count;
    460. 			long r_count;
    461. 			long w_wait;
    462. 			if (GetCount(ignored, w_count, r_count, w_wait))
    463. 			{
    464. 				return 0 == w_count + r_count + w_wait;
    465. 			}
    466. 			return false;
    467. 		}
    468. 		bool GetCount(bool& ignored, long& w_count, long& r_count, long& w_wait)const
    469. 		{
    470. 			long w;
    471. 			ignored = isIngore;
    472. 			return GetCount2(w, w_count, r_count, w_wait);
    473. 		}
    474. 		bool GetCount2(long& w, long& w_count, long& r_count, long& w_wait)const
    475. 		{
    476. 			w = 0;
    477. 			w_count = 0;
    478. 			r_count = 0;
    479. 			w_wait = 0;
    480. 			if (nullptr != sem_id)
    481. 			{
    482. 				w = !sem_id->OnW;
    483. 				w_count = sem_id->OnW;
    484. 				r_count = sem_id->R_count;
    485. 				w_wait = sem_id->W_wait;
    486. 			}
    487. 			return true;
    488. 		}
    489. 	};
    490.  
    491.

            这部分主要是加入了跟踪调试的功能，具体解释待续。

    （这里是结束）

  • 相关阅读:
    手把手教学！新一代 Kaldi: TTS Runtime ASR 实时本地语音识别 语音合成来啦
    158_模型_Power BI 使用 DAX + SVG 打通制作商业图表几乎所有可能
    ppt录屏没有声音？超实用教程来了！
    微信小程序基于Promise封装发起网络请求
    python最常用的三种输出格式
    如何用Redis实现分布式锁？
    JavaScript 基本语法
    使用Python实现强化学习算法
    大语言模型(LLM)综述(二)：开发大语言模型的公开可用资源
    【Rust日报】2022-08-20 将 Rust 带入太空 - 为 VA108XX MCU 系列建立 Rust 生态系统
  • 原文地址：https://blog.csdn.net/2301_77171572/article/details/134472732