引用计数线程是否安全

Question

例如考虑

class ProcessList {
private
   std::vector<std::shared_ptr<SomeObject>> list;
   Mutex mutex;
public:
   void Add(std::shared_ptr<SomeObject> o) { 
       Locker locker(&mutex); // Start of critical section. Locker release so will the mutex - In house stuff
       list.push_back(std::make_shared<SomeObject>(o).
   }

   void Remove(std::shared_ptr<SomeObject> o) { 
       Locker locker(&mutex); // Start of critical section. Locker release so will the mutex - In house stuff
       // Code to remove said object but indirectly modifying the reference count in copy below
   }

   void Process() {
       std::vector<std::shared_ptr<SomeObject>> copy;

       {
           Locker locker(&mutes);
           copy = std::vector<std::shared_ptr<SomeObject>>(
                list.begin(), list.end()
           )
       }
       for (auto it = copy.begin(), it != copy.end(); ++it) {
           it->Procss(); // This may take time/add/remove to the list
       }
    }
};

一个线程运行Process。多个线程运行添加/删除。

引用计数是否安全且始终正确 - 还是应该在其周围放置互斥体？

Answer 1

是的，旨在要求引用计数是线程安全的标准（在 §20.8.2.2 中，至少从 N3997 开始）。

对于像Add这样的简单案例：

void Add(std::shared_ptr<SomeObject> o) { 
    Locker locker(&mutex);
    list.push_back(std::make_shared<SomeObject>(o).
}

...标准中的保证足够强大，您不需要互斥锁，因此您可以：

void Add(std::shared_ptr<SomeObject> o) { 
    list.push_back(std::make_shared<SomeObject>(o).
}

对于您的某些操作，线程安全引用计数是否一定会消除您的互斥锁，这一点并不明确。例如，在您的 Process 中，您有：

   {
       Locker locker(&mutes);
       copy = std::vector<std::shared_ptr<SomeObject>>(
            list.begin(), list.end()
       )
   }

这会将整个复制作为原子操作执行——在复制期间没有其他内容可以修改列表。这可确保您的副本为您提供与开始副本时完全相同的列表快照。如果您消除互斥体，引用计数仍将起作用，但您的副本可能会反映在制作副本时所做的更改。

换句话说，shared_ptr 的线程安全性仅确保每个单独的递增或递减都是原子的——它不能确保整个列表的操作都是原子的，就像在这种情况下互斥锁所做的那样。

由于您的list 实际上是vector，您应该能够将复制代码稍微简化为copy = list。

另请注意，您的 Locker 似乎是 std::lock_guard 提供的一个子集。看来您可以使用：

std::lock_guard<std::mutex> locker(&mutes);

...很容易就位。

Answer 2

使用互斥体进行引用计数将是一种开销。

在内部，互斥锁使用原子操作，基本上互斥锁执行内部线程安全引用计数。因此，您可以直接使用原子来进行引用计数，而不是使用互斥体，这实际上是做双倍的工作。

Answer 3

除非您的 CPU 架构具有原子增量/减量，并且您将其用于引用计数，否则，不，这不安全； C++ 不保证任何标准类型上的 x++/x-- 操作的线程安全。

如果您的编译器支持 (C++11)，请使用 atomic<int>，否则您将需要锁定。

更多参考资料：

• https://www.threadingbuildingblocks.org/docs/help/tbb_userguide/Atomic_Operations.htm