c++怎么实现一个无锁队列(lock-free queue)_c++原子操作实现无锁并发结构

#include <atomic>
#include <memory>

template<typename T>
class LockFreeQueue {
private:
    struct Node {
        std::shared_ptr<T> data;
        std::atomic<Node*> next;

        Node() : data(nullptr), next(nullptr) {}

        Node(const T& d) : data(std::make_shared<T>(d)), next(nullptr) {}
    };

    std::atomic<Node*> head;
    std::atomic<Node*> tail;

    // 辅助函数：尝试释放已出队的节点
    void free_if_need(Node* old_head) {
        if (old_head) {
            delete old_head;
        }
    }

public:
    LockFreeQueue() {
        Node* dummy = new Node();
        head.store(dummy, std::memory_order_relaxed);
        tail.store(dummy, std::memory_order_relaxed);
    }

    ~LockFreeQueue() {
        while (Node* h = head.load()) {
            head.store(h->next.load());
            delete h;
        }
    }

    void enqueue(const T& data) {
        Node* new_node = new Node(data);
        Node* old_tail = nullptr;
        Node* next = nullptr;

        while (true) {
            old_tail = tail.load(std::memory_order_acquire);
            next = old_tail->next.load(std::memory_order_acquire);

            // 检查 tail 是否滞后
            if (old_tail != tail.load(std::memory_order_acquire)) {
                continue; // 重新尝试
            }

            // 如果 tail 没有指向最后一个节点，尝试推进 tail
            if (next != nullptr) {
                tail.compare_exchange_weak(old_tail, next, std::memory_order_release, std::memory_order_acquire);
                continue;
            }

            // 尝试将新节点链接到 tail 后
            if (old_tail->next.compare_exchange_weak(next, new_node, std::memory_order_release, std::memory_order_acquire)) {
                break; // 成功链接
            }
        }

        // 尝试更新 tail 指向新节点
        tail.compare_exchange_weak(old_tail, new_node, std::memory_order_release, std::memory_order_acquire);
    }

    std::shared_ptr<T> dequeue() {
        Node* old_head = nullptr;
        while (true) {
            old_head = head.load(std::memory_order_acquire);
            Node* old_tail = tail.load(std::memory_order_acquire);
            Node* next = old_head->next.load(std::memory_order_acquire);

            // 判断队列是否为空
            if (old_head == old_tail) {
                if (next == nullptr) {
                    return std::shared_ptr<T>(); // 队列空
                }
                // tail 滞后，尝试推进
                tail.compare_exchange_weak(old_tail, next, std::memory_order_release, std::memory_order_acquire);
                continue;
            }

            // 读取数据并尝试移动 head
            if (head.compare_exchange_weak(old_head, next, std::memory_order_release, std::memory_order_acquire)) {
                std::shared_ptr<T> res = next->data;
                // 延迟释放 old_head（注意：生产环境应使用 hazard pointer 或 RCU）
                free_if_need(old_head);
                return res;
            }
        }
    }
};