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

以下是使用无锁双向链表（Lock-Free Doubly Linked List）实现的优化版本：

#include #include

template class LockFreeQueue { public:

LockFreeQueue() : head_(new Node), tail_(head_.load()) {}
~LockFreeQueue()
{
    while (Node *old_head = head_)
    {
        head_ = 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 *prev = tail->prev_.load(std::memory_order_acquire);
    new_node->prev_.store(tail, std::memory_order_relaxed);
    while (!tail_.compare_exchange_weak(tail, new_node, std::memory_order_release, std::memory_order_relaxed))
    {
        prev = tail->prev_.load(std::memory_order_acquire);
        new_node->prev_.store(tail, std::memory_order_relaxed);
    }
    if (prev != tail) // The tail has been updated by another thread
    {
        new_node->prev_.store(prev, std::memory_order_relaxed);
        prev->next_.store(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_acquire);
    if (!new_head)
    {
        return false;
    }
    Node *next = new_head->next_.load(std::memory_order_acquire);
    while (true)
    {
        if (head_.compare_exchange_weak(old_head, new_head, std::memory_order_release, std::memory_order_relaxed))
        {
            break;
        }
        old_head = head_.load(std::memory_order_relaxed);
        new_head = old_head->next_.load(std::memory_order_acquire);
        if (!new_head)
        {
            return false;
        }
        next = new_head->next_.load(std::memory_order_acquire);
    }
    value = new_head->value_;
    if (next)
    {
        next->prev_.store(old_head, std::memory_order_relaxed);
    }
    delete old_head;
    size_.fetch_sub(1, std::memory_order_release);
    return true;
}

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

private:

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

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

};