ZBLOG

std::atomic m_lock;//队列正在析构

在 C++ 中,std::atomic<bool> 是一个原子布尔类型,用于确保对该变量的访问是线程安全的。通过将 m_lock 定义为 std::atomic<bool>,你可以在多线程环境中安全地检查和设置锁的状态,避免数据竞争。

如果你希望使用 m_lock 来表示队列是否正在析构,可以这样做:

示例代码

下面是一个简单示例,演示了如何使用 std::atomic<bool> 来管理一个队列的析构状态。

  1. #include <iostream>
  2. #include <queue>
  3. #include <thread>
  4. #include <atomic>
  5. #include <chrono>
  6. class SafeQueue {
  7. public:
  8. SafeQueue() : m_lock(false) {}
  9. void enqueue(int value) {
  10. // 等待直到队列不在析构中
  11. while (m_lock.load(std::memory_order_acquire)) {
  12. std::this_thread::yield(); // 避免忙等
  13. }
  14. // 加锁
  15. m_lock.store(true, std::memory_order_release);
  16. // 执行入队操作
  17. m_queue.push(value);
  18. // 解锁
  19. m_lock.store(false, std::memory_order_release);
  20. }
  21. void dequeue() {
  22. // 等待直到队列不在析构中
  23. while (m_lock.load(std::memory_order_acquire)) {
  24. std::this_thread::yield(); // 避免忙等
  25. }
  26. // 加锁
  27. m_lock.store(true, std::memory_order_release);
  28. if (!m_queue.empty()) {
  29. int value = m_queue.front();
  30. m_queue.pop();
  31. std::cout << "Dequeued: " << value << std::endl;
  32. } else {
  33. std::cout << "Queue is empty!" << std::endl;
  34. }
  35. // 解锁
  36. m_lock.store(false, std::memory_order_release);
  37. }
  38. ~SafeQueue() {
  39. // 在析构时加锁,标记为正在析构
  40. m_lock.store(true, std::memory_order_release);
  41. // 清空队列(此处可以执行其他清理操作)
  42. while (!m_queue.empty()) {
  43. m_queue.pop();
  44. }
  45. // 解除锁定状态标识
  46. m_lock.store(false, std::memory_order_release);
  47. }
  48. private:
  49. std::queue<int> m_queue; // 使用标准库队列来存储元素。
  50. std::atomic<bool> m_lock; // 原子布尔值,指示是否正在析构。
  51. };
  52. void producer(SafeQueue& queue) {
  53. for (int i = 0; i < 10; ++i) {
  54. queue.enqueue(i);
  55. std::this_thread::sleep_for(std::chrono::milliseconds(100));
  56. }
  57. }
  58. void consumer(SafeQueue& queue) {
  59. for (int i = 0; i < 10; ++i) {
  60. queue.dequeue();
  61. std::this_thread::sleep_for(std::chrono::milliseconds(150));
  62. }
  63. }
  64. int main() {
  65. SafeQueue queue;
  66. std::thread t1(producer, std::ref(queue));
  67. std::thread t2(consumer, std::ref(queue));
  68. t1.join();
  69. t2.join();
  70. return 0;
  71. }

解释

  • 原子性std:atomic<bool> m_lock 确保对其访问是原子的,可以防止多个线程同时修改它而导致的数据竞争。
  • 加锁与解锁:通过设置和清除 m_lock 的值,我们可以控制何时允许其他线程访问队列。在 enqueue 和 dequeue 操作中,这样可以确保线程安全。
  • 等待机制:在操作前,如果 m_lock 被设置为 true(表示对象正在析构),则当前线程会等待(通过调用 std: this_thread: yield() 来避免繁忙轮询)。
  • 自定义类:使用这种方式,你可以扩展并实现更复杂的数据结构,同时保持线程安全性。

请注意,在实际应用中,不建议直接使用类似忙等待的方案,因为这可能导致性能问题。这里仅作为一个简化示例,如果需要高效且响应灵敏的设计,通常会考虑条件变量或信号量等机制。


内容由零声教学AI助手提供,问题来源于学员提问

本站部分文章来源于网络,版权归原作者所有,如有侵权请联系站长删除。
转载请注明出处:https://golang.0voice.com/?id=22662

分享:
扫描分享到社交APP
上一篇
下一篇
发表列表
游客 游客
此处应有掌声~
评论列表

还没有评论,快来说点什么吧~

联系我们

在线咨询: 点击这里给我发消息

微信号:3007537140

上班时间: 10:30-22:30

关注我们
x

注册

已经有帐号?