无锁堆栈：在 pop() 期间检查危险指针时的可见性问题？

Posted 2023-02-22

【中文标题】无锁堆栈：在 pop() 期间检查危险指针时的可见性问题？

【英文标题】：Lock-free stack: visibility issue when checking hazard pointers during pop()?

【发布时间】：2016-12-22 22:24:21

【问题描述】：

我正在阅读 Anthony William 的 C++ Concurrency in Action。第 7 章描述了开发无锁堆栈的过程，并说明了使无锁编程变得困难的常见问题。具体来说，第 7.2.3 节（检测无法使用危险指针回收的节点）描述了如何使用危险指针来避免数据竞争并确保其他线程不会deletea节点仍然被另一个线程引用。

此代码是该章中说明的pop() 的迭代之一：

std::shared_ptr<T> pop()

  std::atomic<void*>& hp = get_hazard_pointer_for_current_thread();
  node* old_head = head.load();

  do
  
    node* temp;

    do
    
      temp = old_head;
      hp.store(old_head);
      old_head = head.load();
     while(old_head != temp);
  
  while(old_head &&
    !head.compare_exchange_strong(old_head,old_head->next));

  hp.store(nullptr);
  std::shared_ptr<T> res;

  if(old_head)
  
    res.swap(old_head->data);

    if(outstanding_hazard_pointers_for(old_head))
    
      reclaim_later(old_head);
    
    else
    
      delete old_head;
    

    delete_nodes_with_no_hazards();
  

  return res;

我对这个片段有疑问：

    if(outstanding_hazard_pointers_for(old_head))
    
      reclaim_later(old_head);
    
    else
    
      delete old_head;
    

危险指针的目的是确保在没有其他线程可能仍在使用它时删除old_head。 outstanding_hazard_pointers_for 的建议实现如下：

unsigned const max_hazard_pointers=100;
struct hazard_pointer

  std::atomic<std::thread::id> id;
  std::atomic<void*> pointer;
;
hazard_pointer hazard_pointers[max_hazard_pointers];

bool outstanding_hazard_pointers_for(void* p)

  for(unsigned i=0; i < max_hazard_pointers; ++i)
  
    if(hazard_pointers[i].pointer.load() == p)
    
      return true;
    
  

  return false;

基本上，扫描危险指针数组以检查是否存在指向所查找节点的指针。我想知道为什么这个操作确实是安全的。执行原子load()，即使使用顺序一致的排序，load() 也可能加载陈旧的值。因此，p 可能找不到，pop() 将删除仍在使用的节点。

想象一下会发生以下情况：

线程A开始执行pop()并在执行前被抢占刚刚：

while(old_head &&
  !head.compare_exchange_strong(old_head,old_head->next));

因此，线程 A 将当前头视为old_head，并将其保存到其危险指针中。当线程唤醒并尝试弹出调用 head.compare_exchange_strong(old_head, old_head->next) 的头部时，old_head 将被取消引用。

线程 B 开始调用 pop() 到

if(outstanding_hazard_pointers_for(old_head))

old_head 将是堆栈的当前头，即线程 A 引用为 old_head 的同一节点。如果线程 A 的危险指针上的 load() 返回线程 A 存储的最新值，线程 B 将不会 delete old_head。

基本上：我想知道线程 B 是否可以load() 一个陈旧的值而不是最新的值。换句话说，我不确定为什么它必须返回由线程 A (old_node) 设置的值。

这种推理的缺陷在哪里？我找不到理由说明为什么另一个线程上的hp.store(old_head) 会在hazard_pointers[i].pointer.load() 之前发生。

【问题讨论】：

我正在看这本书，和你有完全相同的问题。我目前不明白下面的答案如何回答您的问题。既然你有同样的理解问题，你能否重新表述一下你描述的场景不能发生的原因，并且我们在危险 ptr 列表扫描和 CAS 之前的存储之间存在“之前发生”？

JJ15k，我刚刚回答了你的问题。

【参考方案1】：

我回答自己的问题有两个原因：我认为我接受的答案不是很清楚，JJ15k's comment 证实了这种印象。

基本上，关键是观察另一个线程通过if(outstanding_hazard_pointers_for(old_head)) 和看到另一个线程看到的相同old_head在执行while(old_head && !head.compare_exchange_strong(old_head, old_head->next))之前被抢占，它必须有用相同的old_head 执行head.compare_exchange_strong(old_head, old_head->next)。但是随后（假设< 表示发生前的关系）：

thread A: hp.store(old_head)     < 
thread A: old_head = head.load() < 
thread B: head.compare_exchange_strong(old_head, old_head->next)

请记住，线程 B 看到 相同 我们在第一条指令中加载的 old_head，并将其值交换为 old_head->next。我们仍然在 head.load() 中看到相同的值，这就是为什么线程 A hp.store(old_head) 发生在线程 B compare_exchange_strong 之前。

所以即将检查危险指针中包含的头部是否可以删除的线程已经看到old_head。还要注意old_head = head.load() 所扮演的基本角色（以及包含那些乍一看似乎多余的语句的循环）。如果没有那个load 操作，old_head 的store 到hp 和compare_exchange_strong 之间就不会有happens-before 关系。

我希望这能回答你的问题。

【讨论】：

首先感谢您抽出宝贵时间！我正在考虑它，但是：在关系之前第二次发生的力量是什么？我没有看到在 B 中读取来自 A 的释放写入。我想我可以在缓存一致性级别上理解它，因为 XCH 将使所有副本无效，但我仍然无法说服自己使用 C++ 内存模型。

您不应该在该代码中寻找获取-释放语义：所有原子操作都使用顺序一致的内存顺序。

是的，这就是我正在探索的，与内存位置上的全局总顺序相关的推理。我一直很忙，没有考虑它需要的想法。在接下来的几天内会这样做

知道了，我的困惑源于没有意识到一个事实：在顺序一致的模型中，对于每两个操作 A 和 B，A 发生在 B 之前，或者 B 发生在 A 之前。这是相反的释放/获取条件是 B 获取发生在发布 A 之后，或者您只是不知道。再次感谢您的帮助。

【参考方案2】：

我对代码的理解如下。

如果hp.store(old_head)在另一个线程中没有发生-在这个线程调用hazard_pointers[i].pointer.load()之前，这意味着这个线程成功地执行了head.compare_exchange_strong(old_head,old_head->next)调用。这意味着对于另一个线程old_head != temp，因此它将再次尝试将正确的old_head存储为线程的hp。

这意味着可以安全地删除当前线程中的原始old_head指针，因为它实际上并没有被另一个线程使用。

【讨论】：

谢谢@art。我已经用一个例子更新了这个问题。基本上，线程可以在 检查old_head == temp 之后被抢占。另一个线程可以继续，直到检查该节点是否可以被删除。在这种情况下，第一个线程的store() 在第二个线程的load() 中可见是至关重要的。我错误地假设如果不违反顺序一致性，顺序一致的加载可以读取陈旧的值？

您对原始问题进行了重大修改。您对阅读陈旧值的理解是正确的。但是您在修改后的问题中描述的场景也没有问题。线程 B 会将old_head 添加到 reclaim_later 列表中。这样线程 A（或以后的任何其他线程）将能够在 delete_nodes_with_no_hazards 调用期间删除这个未使用的节点。

对不起，如果我再次重申，但这是问题的核心：线程 B 将把 old_head 添加到回收列表中，如果 outstanding_hazard_pointers_for 返回 true。当我说“读取一个陈旧的值”时，我的意思是 outstanding_hazard_pointers_for not 在危险指针数组中找到 old_head（例如：因为 store() 的效果尚不可见），在这种情况下，outstanding_hazard_pointers_for 将返回 false，pop() 将返回 delete 节点。

线程的hp 在while(old_head && !head.compare_exchange_strong(old_head,old_head->next)); 条件之前修改。因此，如果您在线程 B 中观察到来自线程 A 的新 head 值，那么您也会观察到 A 的 hp 的正确值。您看不到 A 的 hp 的旧版本和在 A 中修改的 head 的最新版本。