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

以下是优化后的代码：

#include <atomic>
#include <iostream>

template <typename T>
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;
                break;
            }
        }
    }
    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_acquire);
            if (!next)
            {
                if (tail->next_.compare_exchange_weak(next, new_node, std::memory_order_release))
                {
                    break;
                }
            }
            else
            {
                tail_.compare_exchange_weak(tail, next, std::memory_order_release);
            }
        }
        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_acquire);
        Node *new_head = old_head->next_.load(std::memory_order_acquire);
        if (!new_head)
        {
            return false;
        }
        value = new_head->value_;
        if (head_.compare_exchange_weak(old_head, new_head, std::memory_order_release))
        {
            size_.fetch_sub(1, std::memory_order_release);
            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) {}
    };

    alignas(64) std::atomic<Node *> head_;
    alignas(64) std::atomic<Node *> tail_;
    alignas(64) std::atomic<size_t> size_{0};
};

对比原始代码，我们进行了以下几个优化：