std::atomic m_lock;//队列正在析构-Go服务器开发

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

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

示例代码

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

#include <iostream>
#include <queue>
#include <thread>
#include <atomic>
#include <chrono>

class SafeQueue {
public:
    SafeQueue() : m_lock(false) {}

    void enqueue(int value) {
        // 等待直到队列不在析构中
        while (m_lock.load(std::memory_order_acquire)) {
            std::this_thread::yield(); // 避免忙等
        }
        
        // 加锁
        m_lock.store(true, std::memory_order_release);
        
        // 执行入队操作
        m_queue.push(value);
        
        // 解锁
        m_lock.store(false, std::memory_order_release);
    }

    void dequeue() {
        // 等待直到队列不在析构中
        while (m_lock.load(std::memory_order_acquire)) {
            std::this_thread::yield(); // 避免忙等
        }

        // 加锁
        m_lock.store(true, std::memory_order_release);
        
        if (!m_queue.empty()) {
            int value = m_queue.front();
            m_queue.pop();
            std::cout << "Dequeued: " << value << std::endl;
        } else {
            std::cout << "Queue is empty!" << std::endl;
        }
        
        // 解锁
        m_lock.store(false, std::memory_order_release);
    }

    ~SafeQueue() {
        // 在析构时加锁，标记为正在析构
        m_lock.store(true, std::memory_order_release);

        // 清空队列（此处可以执行其他清理操作）
        while (!m_queue.empty()) {
            m_queue.pop();
        }

        // 解除锁定状态标识
       m_lock.store(false, std::memory_order_release);
    }

private:
    std::queue<int> m_queue;     // 使用标准库队列来存储元素。
    std::atomic<bool> m_lock;     // 原子布尔值，指示是否正在析构。
};

void producer(SafeQueue& queue) {
    for (int i = 0; i < 10; ++i) {
         queue.enqueue(i); 
         std::this_thread::sleep_for(std::chrono::milliseconds(100));
     }
}

void consumer(SafeQueue& queue) { 
   for (int i = 0; i < 10; ++i) { 
       queue.dequeue(); 
       std::this_thread::sleep_for(std::chrono::milliseconds(150)); 
   } 
}

int main() {
    SafeQueue queue;

    std::thread t1(producer, std::ref(queue));
    std::thread t2(consumer, std::ref(queue));

    t1.join();
    t2.join();

   return 0;
}

解释

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