线程安全的复制构造函数/赋值运算符

Question

假设我们想要使用 std::mutex 使类 A 线程安全。我的复制构造函数和赋值运算符与下面的代码类似：

#include <mutex>

class A {
private:
  int i;
  mutable std::mutex mtx;

public:
  A() : i(), mtx() { }

  A(const A& other) : i(), mtx()
  {
    std::lock_guard<std::mutex> _lock(other.mtx);
    i = other.i;
  }

  A& operator=(const A& other)
  {
    if (this!=&other) {
      std::lock_guard<std::mutex> _mylock(mtx), _otherlock(other.mtx);
      i = other.i;
    }
    return *this;
  }

  int get() const
  {
    std::lock_guard<std::mutex> _mylock(mtx);
    return i;
  }
};

我不认为它有任何问题，除了 other 在复制之前被另一个线程销毁的可能性，我认为可以应对。

我的问题是，我在任何地方都没有看到这种模式，所以我不知道人们是否不需要这种模式，或者由于我目前没有看到的原因，这种模式显然是错误的。

谢谢

注意：

这只是一个例子。我可以拥有任意数量的任何类型的成员变量，它不必只是一个 int。

在 Martin York 对可能的死锁发表评论之后，这是一个使用复制和交换的更新版本（复制省略也是可能的，但它不能有效地处理自分配情况）。

我也把int改成了T，所以人们不能认为它是一个POD。

template<typename T>
class A {
private:
  T t;
  mutable std::mutex mtx;

public:
  A() : t(), mtx() { }

  A(const A& other) : t(), mtx()
  {
    std::lock_guard<std::mutex> _lock(other.mtx);
    t = other.t;
  }

  A& operator=(const A& other)
  {
    if (this!=&other) {
      A tmp(other);
      std::lock_guard<std::mutex> _lock(mtx);
      std::swap(t, tmp.t);
    }
    return *this;
  }

  T get() const
  {
    std::lock_guard<std::mutex> _lock(mtx);
    return t;
  }

};

Answer 1

老问题，新答案：

恕我直言，处理原始复制赋值运算符的死锁问题的更好方法是：

  A& operator=(const A& other)
  {
    if (this!=&other) {
      std::unique_lock<std::mutex> _mylock(mtx, std::defer_lock),
                                   _otherlock(other.mtx, std::defer_lock);
      std::lock(_mylock, _otherlock);
      i = other.i;
    }
    return *this;
  }

即使用 std::lock(L1, L2) 同时锁定两者互斥体而不用担心死锁。这可能比复制/交换习惯用法具有更高的性能，特别是当成员数据由 std::vector、std::string 或包含向量的类型组成时和/或字符串。

在 C++1y 中（我们希望 y 为 4），有一个新的 标头提供读/写锁定功能，可能提供性能提升（性能对于特定用例需要进行测试来确认这一点）。下面是它的使用方式：

#include <mutex>
#include <shared_mutex>

class A {
private:
  int i;
  mutable std::shared_mutex mtx;

public:
  A() : i(), mtx() { }

  A(const A& other) : i(), mtx()
  {
    std::shared_lock<std::shared_mutex> _lock(other.mtx);
    i = other.i;
  }

  A& operator=(const A& other)
  {
    if (this!=&other) {
      std::unique_lock<std::shared_mutex> _mylock(mtx, std::defer_lock);
      std::shared_lock<std::shared_mutex> _otherlock(other.mtx, std::defer_lock);
      std::lock(_mylock, _otherlock);
      i = other.i;
    }
    return *this;
  }

  int get() const
  {
    std::shared_lock<std::shared_mutex> _mylock(mtx);
    return i;
  }
};

即，这与原始代码非常相似（修改为使用 std::lock ，就像我上面所做的那样）。但成员互斥体类型现在是 std::shared_mutex 而不是 std::mutex。当保护 const A 时（假设除了互斥体之外没有可变成员），只需将互斥体锁定在“共享模式”即可。使用shared_lock可以轻松完成此操作。当您需要以“独占模式”锁定互斥锁时，可以根据需要使用 unique_lock 或 lock_guard，并且方式与您相同可以将此功能与 std::mutex 一起使用。

特别注意，现在许多线程可以同时从同一个 A 复制构造，甚至从同一个 A 复制分配。但一次仍然只有一个线程可以将复制分配给同一个A。

Answer 2

忽略所有实现细节，您看不到此模式的原因是您很可能锁定了错误的抽象级别。

• 如果从多个线程访问对象，那么您（另外）必须管理对象的生命周期，而不能从对象内部管理对象的生命周期。
• 对于生命周期管理，您已经需要至少一个对象外部锁，因此最好使用它。
• 此方案仅对单 get() 对象有意义 - 如果您的对象具有多个（多个成员或多个）get() 函数，则从该对象可能/将会导致数据不一致。

获得正确的多线程代码不仅仅是确保没有“崩溃”并且单个对象保持一致状态的问题。如果您（认为您）需要上述方案，您可能会认为当您的应用程序仍在做错误的事情时您就得救了。

至于实现细节：由于您已经为此使用 C++0x，因此您还应该实现适当定义的移动操作。

Answer 3

我不是这方面的权威，因为多线程很棘手，但到目前为止看起来还不错。
顺便说一句，您可能的意思

std::lock_guard<std::mutex>

是在复制因子中：

A(const A& other) : mtx()
{
  std::lock_guard<std::mutex> _lock(other.mtx);
  i = other.i;
}

确保 other 线程安全的另一种方法是仅使用“安全”getters 来访问它，尽管当多个 getters 时，这不会按预期运行。叫。但是，请注意引用！

Answer 4

您实际上并没有看到它，因为标准线程设施非常新，而且我不知道有哪个编译器支持它们 - 您需要进一步寻找 boost::thread 示例。另外，无端使用同步可能会导致性能不佳，但这只是我的观点。

Answer 5

这是更正确的，但并不完全可靠：

#include <mutex>

class A {
private:
    int i;
    std::mutex mtx;

public:
    A() : i(0), mtx() {
    }
    /* this is one option for implementation, but would be rewritten when there are more ivars in order to reduce acquisition counts */
    A(A& other) : i(other.get()), mtx() {
    }

    ~A() {
        /* unsafe if subclassed, also useful for determining whether objects are destroyed prematurely (e.g., by their containers */
        std::lock_guard<std::mutex> _mylock(this->mtx);
    }

    A& operator=(A& other) {
        std::lock_guard<std::mutex> _mylock(this->mtx);
        std::lock_guard<std::mutex> _otherlock(other.mtx);
        this->i = other.i; /* you could call other.get() and bypass the lock_guard, but i'm assuming there's really more work to be done here */
        return *this;
    }

    int get() {
        std::lock_guard<std::mutex> _mylock(this->mtx);
        return this->i;
    }
private:
    /* prohibited */
    A(const A& other);
    /* also prohibited */
    A& operator=(const A& other);
};