快速锁定大量读取且偶尔可能从另一个线程更改的变量

Question

我正在寻找一种锁，它允许在 GUI 和后端之间进行线程安全的转换。

只是为了双倍，但我相信它最终会被用于其他事情。

现在这是我不确定的部分，在现代 CPU 上，是否可以同时读取和写入导致竞争条件？还是只有当两个线程同时尝试写入时。

我总是将与线程交叉的所有变量都封装在一个模板对象中，这允许我同样使用但需要锁定，这里是基础：

//=====================================================================================================
// Class to store a variable in a thread safe manner.
//=====================================================================================================
template <class T>
class ThreadSafeVariable
{
public:

  ThreadSafeVariable(const T & variable):
    _stored_variable(variable)
  {
  }

  ThreadSafeVariable():
    _stored_variable()
  {
  }

  //=====================================================================================================
  /// Returns the stored variable
  //=====================================================================================================
  T Read() const
  {
    boost::unique_lock<boost::mutex> lock(_mutex);
    return _stored_variable;
  }


  //=====================================================================================================
  /// Sets the variable
  //=====================================================================================================
  void operator = (const T &value_to_set)
  {
    boost::unique_lock<boost::mutex> lock(_mutex);
    _stored_variable = value_to_set;
  }


  //=====================================================================================================
  /// Returns the stored variable
  //=====================================================================================================
  operator T() const
  {
    boost::unique_lock<boost::mutex> lock(_mutex);
    return (T) _stored_variable;
  }


  void SetFromString (const std::string & value_to_set);
  T operator ++ (int);
  T operator -- (int);
  std::string ToString() const;

  protected:
  T _stored_variable;
  mutable boost::mutex _mutex;
};

如果只有一个线程可以选择写入（该部分需要通过调用不同的函数进行编码），是否有可能使这样的类更快。

基本上我有一个静态函数，我想保持静态，它会根据我想在 GUI 上更改的参数而变化，但它是软件的性能关键部分。

我知道自旋锁，原子。但从未真正使用过它们。我猜自旋锁会浪费 CPU，而且我不确定原子能带来的性能提升。

Answer 1

你应该看看std::atomic<>，它几乎完全实现了你需要的行为。不要重新发明轮子。

std::atomic<> 的好处在于，它实际上使用了用于原子读写的硬件设施，因此std::atomic<> 的所有基本实例实际上都是无锁的，这是一个巨大的速度加成。甚至还有一些预处理器宏指示std::atomic<> 的哪些基本实例是以无锁方式实现的，这使您可以选择最合适的无锁实例（例如，ATOMIC_CHAR_LOCK_FREE 就是其中之一）。

---

以下是只读和并发写入之间可能的竞争的解释。 不要试图将其解读为在语言标准之外进行任何操作的说明。如果你忽略标准而出现鼻恶魔，那不在我的部门。

关于您关于读写之间是否存在竞争条件的问题，这实际上取决于具体情况。通常，您可以假设机器本机支持的自然对齐类型的单个读取或写入将以原子方式处理。即，在 64 位机器上，如果 uint64_t 与八字节边界对齐，则可以预期 uint64_t 的读取和写入是原子的。如果不满足这些条件，您最终可能会遇到这样一种情况：您从内存中读取的值的一半来自写入之前的值，而另一半来自写入的值。例如，如果你这样做

while(1) {
    myGlobal = 0x0000000000000000;
    myGlobal = 0x0123456789abcdef;
}

并发

printf("0x%016llu\n", myGlobal);

而myGlobal 未正确对齐，或者在 32 位机器上运行，您可能会发现输出为 0x0123456700000000。

C++ 语言的定义方式忽略了这些实现细节，因此任何包含至少一次写入的变量的并发访问都被视为竞争条件。正如std::atomic<> 的存在所承认的那样，这在安全方面有点远。 依赖这些保证但不使用std::atomic<>的代码也是非常危险的，因为它允许优化器歪曲程序员的假设（关于这方面的更多信息可以在这个简短的文章 Boehm.pdf ，感谢 nosid 的链接）。

因此，std::atomic<> 是在 C++ 标准的支持下获得无锁、线程安全变量的唯一方法。