#include #include template class LockFreeQueue { public: LockFreeQueue() : head_(new Node), tail_(head_.load()) {} ~LockFreeQueue() { while (Node *old_head = head

问题：在 push() 函数中，tail_.compare_exchange_weak(tail, next, std::memory_order_release, std::memory_order_relaxed) 语句没有一个循环，可能会导致死循环。在 trypop() 函数中，如果 head 和 new_head 相等，也就是队列为空时，仍然进行了 delete old_head 操作。

优化：在 push() 函数中，在 while 循环的条件中加入对 tail 的重新加载，避免死循环的发生。在 try_pop() 函数中，在判断队列是否为空之后再进行 delete 操作。

改进后的代码如下：

#include #include

template class LockFreeQueue { public:

LockFreeQueue() : head_(new Node), tail_(head_.load()) {}
~LockFreeQueue()
{
    while (Node *old_head = head_.load())
    {
        Node *next = old_head->next_;
        if (head_.compare_exchange_weak(old_head, next))
        {
            delete old_head;
        }
    }
}

void push(const T &value)
{
    Node *new_node = new Node(value);
    Node *tail = tail_.load(std::memory_order_relaxed);
    Node *next = nullptr;
    while (true)
    {
        next = tail->next_.load(std::memory_order_relaxed);
        if (!next)
        {
            if (tail->next_.compare_exchange_weak(next, new_node, std::memory_order_release, std::memory_order_relaxed))
            {
                break;
            }
            tail = tail_.load(std::memory_order_relaxed); // 重新加载 tail
        }
        else
        {
            tail_.compare_exchange_weak(tail, next, std::memory_order_release, std::memory_order_relaxed);
            tail = tail_.load(std::memory_order_relaxed); // 重新加载 tail
        }
    }
    tail_.compare_exchange_weak(tail, new_node, std::memory_order_release);
    size_.fetch_add(1, std::memory_order_release);
}

bool try_pop(T &value)
{
    Node *old_head = head_.load(std::memory_order_relaxed);
    Node *new_head = old_head->next_.load(std::memory_order_relaxed);
    if (!new_head)
    {
        return false;
    }
    value = new_head->value_;
    if (head_.compare_exchange_weak(old_head, new_head, std::memory_order_release, std::memory_order_relaxed))
    {
        size_.fetch_sub(1, std::memory_order_release);
        old_head->value_ = T(); // 置空，避免 delete 操作时引发问题
        delete old_head;
        return true;
    }
    return false;
}

bool empty() const
{
    return size_.load(std::memory_order_acquire) == 0;
}

private:

struct Node
{
    T value_;
    std::atomic<Node *> next_;
    Node() : value_(T()), next_(nullptr) {}
    explicit Node(const T &value) : value_(value), next_(nullptr) {}
};

std::atomic<Node *> head_;
std::atomic<Node *> tail_;
std::atomic<size_t> size_{0};

};