这是带有 shared_ptr 的正确 C++11 双重检查锁定版本吗？

Question

Jeff Preshing 的 article 声明双重检查锁定模式 (DCLP) 在 C++11 中是固定的。用于此模式的经典示例是单例模式，但我碰巧有一个不同的用例，我仍然缺乏处理“原子武器”的经验——也许这里有人可以帮助我。

以下代码是 Jeff 在"Using C++11 Sequentially Consistent Atomics" 下描述的正确 DCLP 实现吗？

class Foo {
    std::shared_ptr<B> data;
    std::mutex mutex;

    void detach()
    {
      if (data.use_count() > 1)
      {
        std::lock_guard<std::mutex> lock{mutex};
        if (data.use_count() > 1)
        {
          data = std::make_shared<B>(*data);
        }
      }
    }

public:
  // public interface
};

Answer 1

不，这不是 DCLP 的正确实现。

问题是您的外部检查 data.use_count() > 1 访问对象（类型为B with reference count），可以在互斥保护部分删除（未引用） .任何形式的记忆栅栏都无济于事。

为什么 data.use_count() 访问对象：

假设这些操作已经执行：

shared_ptr<B> data1 = make_shared<B>(...);
shared_ptr<B> data = data1;

那么您有以下布局（weak_ptr 支持未在此处显示）：

         data1             [allocated with B::new()]         data
                           --------------------------
 [pointer type] ref; -->   |atomic<int> m_use_count;|    <-- [pointer type] ref
                           |B obj;                  |
                           --------------------------

每个shared_ptr 对象只是一个指针，它指向分配的内存区域。这个内存区域嵌入了B 类型的对象加上原子计数器，反映了shared_ptr 的数量，指向给定的对象。当这个计数器变为零时，内存区域被释放（并且B 对象被销毁）。正是这个计数器由shared_ptr::use_count() 返回。

UPDATE：执行，可能导致访问已经释放的内存（最初，两个shared_ptr指向同一个对象，.use_count()为2）：

/* Thread 1 */                   /* Thread 2 */       /* Thread 3 */
Enter detach()                   Enter detach()
Found `data.use_count()` > 1     
Enter critical section                                   
Found `data.use_count()` > 1
                                 Dereference `data`,
                                 found old object.
Unreference old `data`,
`use_count` becomes 1 
                                                      Delete other shared_ptr,
                                                      old object is deleted
Assign new object to `data`
                                 Access old object
                                 (for check `use_count`)
                                 !! But object is freed !!

外部检查只需要一个指向对象的指针来决定是否需要获取锁。

顺便说一句，即使你的实现也是正确的，它有一点意义：

1. 如果可以同时从多个线程访问data（和detach），则对象的唯一性没有任何优势，因为它可以从多个线程访问。如果你想改变对象，所有对data的访问都应该受到外部互斥锁的保护，这样detach()就不能同时执行了。

2. 如果data（和detach）只能被单线程同时访问，detach的实现根本不需要任何锁定。

Answer 2

如果两个线程同时在 Foo 的同一实例上调用 detach，这将构成数据竞争，因为 std::shared_ptr<B>::use_count()（只读操作）将与 std::shared_ptr<B> 移动赋值运算符（a修改操作），这是一个数据竞争，因此是未定义行为的原因。另一方面，如果 Foo 实例永远不会同时访问，则不会存在数据竞争，但 std::mutex 在您的示例中将毫无用处。问题是：data 的指针是如何被共享的？如果没有这一关键信息，即使从未同时使用 Foo，也很难判断代码是否安全。

Answer 3

根据您的消息来源，我认为您仍然需要在第一次测试之前和第二次测试之后添加线程围栏。

std::shared_ptr<B> data;
std::mutex mutex;

void detach()
{
  std::atomic_thread_fence(std::memory_order_acquire);
  if (data.use_count() > 1)
  {
    auto lock = std::lock_guard<std::mutex>{mutex};
    if (data.use_count() > 1)
    {
      std::atomic_thread_fence(std::memory_order_release);
      data = std::make_shared<B>(*data);
    }
  }
}