以下是优化后的代码：
#include
template
LockFreeQueue() : head_(new Node), tail_(head_.load()) {}
~LockFreeQueue()
{
while (Node *old_head = head_.load())
{
Node *next = old_head->next_.load(std::memory_order_relaxed);
delete old_head;
head_.store(next, std::memory_order_relaxed);
}
}
void push(const T &value)
{
Node *new_node = new Node(value);
Node *tail = tail_.load(std::memory_order_relaxed);
while (!tail->next_.compare_exchange_weak(nullptr, new_node, std::memory_order_release, std::memory_order_relaxed))
{
tail_.compare_exchange_weak(tail, tail->next_.load(std::memory_order_relaxed),
std::memory_order_relaxed, std::memory_order_relaxed);
tail = tail_.load(std::memory_order_relaxed);
}
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 = nullptr;
do
{
if (!old_head->next_)
{
return false;
}
new_head = old_head->next_.load(std::memory_order_relaxed);
} while (!head_.compare_exchange_weak(old_head, new_head, std::memory_order_release, std::memory_order_relaxed));
value = new_head->value_;
size_.fetch_sub(1, std::memory_order_release);
delete old_head;
return true;
}
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};
};
主要优化包括以下几点：
在析构函数中的内存释放过程中，使用循环而非递归方式，避免栈溢出等问题。
在 push() 函数中，通过 while 循环不断尝试插入新节点，直到成功为止，避免了使用 if 判断后需要再次加载 tail_ 的性能损失。
在 try_pop() 函数中，使用 do-while 循环确保操作至少执行一次，以此避免原来的 if 判断可能导致的重试。
在 try_pop() 函数中，将 delete 操作提前，避免了释放节点时可能的竞争。同时，由于此时 old_head 和 new_head 已经没有依赖关系，因此可以使用普通的 store() 替代 compare_exchange_weak()。
在 try_pop() 函数中，将 fetch_sub() 移动至 delete 操作之前，以此避免出现删除一个已经被其他线程取走的节点的情况。
