这个队列的实现存在内存泄漏问题。在析构函数中,只释放了节点本身,而没有释放节点中存储的数据所分配的内存。另外,在push操作中,如果内存池无法分配新的节点,直接返回,但是没有进行任何处理。
以下是针对这些问题的一个优化版本:
#include
template
LockFreeQueue() : head_(new Node), tail_(head_.load()), memory_pool_(sizeof(Node) * 100) {}
~LockFreeQueue()
{
while (Node *const old_head = head_)
{
Node *next_node = old_head->value_.second;
delete old_head->value_.first;
old_head->value_.first = nullptr;
delete old_head;
head_ = next_node;
}
}
void push(const T &value)
{
auto data = new T(value);
Node *new_node = static_cast<Node *>(memory_pool_.Alloc(sizeof(Node)));
if (new_node == nullptr)
{
delete data;
return;
}
new (new_node) Node(std::make_pair(data, nullptr));
Node *tail = tail_.load(std::memory_order_relaxed);
tail->value_.second = new_node;
tail_.store(new_node, std::memory_order_release);
size_.fetch_add(1, std::memory_order_release);
}
bool try_pop(T &value)
{
Node *const old_head = head_.load(std::memory_order_relaxed);
Node *const new_head = old_head->value_.second;
if (new_head == nullptr)
{
return false;
}
value = *(new_head->value_.first);
head_.store(new_head, std::memory_order_release);
size_.fetch_sub(1, std::memory_order_release);
memory_pool_.Free(old_head, sizeof(Node));
delete old_head->value_.first;
old_head->value_.first = nullptr;
return true;
}
bool empty() const
{
return size_.load(std::memory_order_acquire) == 0;
}
private:
struct Node
{
std::pair<T *, Node *> value_;
Node() : value_(std::make_pair(nullptr, nullptr)) {}
explicit Node(const std::pair<T *, Node *> &value) : value_(value) {}
};
std::atomic<Node *> head_;
std::atomic<Node *> tail_;
std::atomic<size_t> size_{0};
terra_memory_pool memory_pool_;
};
优化内容:
在节点中存储的数据类型改为指针类型,避免对象拷贝和赋值。
在push操作中,分配新的节点之后,也要分配存储数据所需的内存,并在构造函数中进行初始化。
在析构函数中,释放节点中存储的数据所分配的内存。