ZBLOG

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

问题:在 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:

  1. LockFreeQueue() : head_(new Node), tail_(head_.load()) {}
  2. ~LockFreeQueue()
  3. {
  4. while (Node *old_head = head_.load())
  5. {
  6. Node *next = old_head->next_;
  7. if (head_.compare_exchange_weak(old_head, next))
  8. {
  9. delete old_head;
  10. }
  11. }
  12. }
  13. void push(const T &value)
  14. {
  15. Node *new_node = new Node(value);
  16. Node *tail = tail_.load(std::memory_order_relaxed);
  17. Node *next = nullptr;
  18. while (true)
  19. {
  20. next = tail->next_.load(std::memory_order_relaxed);
  21. if (!next)
  22. {
  23. if (tail->next_.compare_exchange_weak(next, new_node, std::memory_order_release, std::memory_order_relaxed))
  24. {
  25. break;
  26. }
  27. tail = tail_.load(std::memory_order_relaxed); // 重新加载 tail
  28. }
  29. else
  30. {
  31. tail_.compare_exchange_weak(tail, next, std::memory_order_release, std::memory_order_relaxed);
  32. tail = tail_.load(std::memory_order_relaxed); // 重新加载 tail
  33. }
  34. }
  35. tail_.compare_exchange_weak(tail, new_node, std::memory_order_release);
  36. size_.fetch_add(1, std::memory_order_release);
  37. }
  38. bool try_pop(T &value)
  39. {
  40. Node *old_head = head_.load(std::memory_order_relaxed);
  41. Node *new_head = old_head->next_.load(std::memory_order_relaxed);
  42. if (!new_head)
  43. {
  44. return false;
  45. }
  46. value = new_head->value_;
  47. if (head_.compare_exchange_weak(old_head, new_head, std::memory_order_release, std::memory_order_relaxed))
  48. {
  49. size_.fetch_sub(1, std::memory_order_release);
  50. old_head->value_ = T(); // 置空,避免 delete 操作时引发问题
  51. delete old_head;
  52. return true;
  53. }
  54. return false;
  55. }
  56. bool empty() const
  57. {
  58. return size_.load(std::memory_order_acquire) == 0;
  59. }

private:

  1. struct Node
  2. {
  3. T value_;
  4. std::atomic<Node *> next_;
  5. Node() : value_(T()), next_(nullptr) {}
  6. explicit Node(const T &value) : value_(value), next_(nullptr) {}
  7. };
  8. std::atomic<Node *> head_;
  9. std::atomic<Node *> tail_;
  10. std::atomic<size_t> size_{0};

};

本站部分文章来源于网络,版权归原作者所有,如有侵权请联系站长删除。
转载请注明出处:https://golang.0voice.com/?id=1632

分享:
扫描分享到社交APP
上一篇
下一篇
发表列表
游客 游客
此处应有掌声~
评论列表

还没有评论,快来说点什么吧~

联系我们

在线咨询: 点击这里给我发消息

微信号:3007537140

上班时间: 10:30-22:30

关注我们
x

注册

已经有帐号?