c++ - 我应该如何处理 C++ 中可移动类型中的互斥锁？

Question

通过设计，std::mutex不可移动或复制。这意味着一个类 A持有互斥锁不会收到默认的移动构造函数。
我将如何制作这种类型 A以线程安全的方式移动？

Answer 1

让我们从一些代码开始:

class A
{
    using MutexType = std::mutex;
    using ReadLock = std::unique_lock<MutexType>;
    using WriteLock = std::unique_lock<MutexType>;

    mutable MutexType mut_;

    std::string field1_;
    std::string field2_;

public:
    ...

我在里面放了一些相当有启发性的类型别名，我们不会在 C++11 中真正利用它们，但在 C++14 中变得更加有用。耐心点，我们会到的。

你的问题归结为:

How do I write the move constructor and move assignment operator for this class?

我们将从移动构造函数开始。

移动构造函数

注意成员(member) mutex已制作 mutable .严格来说，这对于移动成员来说不是必需的，但我假设您也需要复制成员。如果不是这种情况，则无需制作互斥锁 mutable .

构建时 A ，您无需锁定 this->mut_ .但是您确实需要锁定 mut_您正在构建的对象的(移动或复制)。这可以像这样完成:

    A(A&& a)
    {
        WriteLock rhs_lk(a.mut_);
        field1_ = std::move(a.field1_);
        field2_ = std::move(a.field2_);
    }

请注意，我们必须默认构造 this 的成员。首先，然后仅在 a.mut_ 之后为它们赋值被锁定。

移动分配

移动赋值运算符要复杂得多，因为您不知道其他线程是否正在访问赋值表达式的 lhs 或 rhs。一般来说，您需要防范以下情况:

// Thread 1
x = std::move(y);

// Thread 2
y = std::move(x);

这是正确保护上述场景的移动赋值运算符:

    A& operator=(A&& a)
    {
        if (this != &a)
        {
            WriteLock lhs_lk(mut_, std::defer_lock);
            WriteLock rhs_lk(a.mut_, std::defer_lock);
            std::lock(lhs_lk, rhs_lk);
            field1_ = std::move(a.field1_);
            field2_ = std::move(a.field2_);
        }
        return *this;
    }

请注意，必须使用 std::lock(m1, m2)锁定两个互斥锁，而不是一个接一个地锁定它们。如果将它们一个接一个地锁定，那么当两个线程以相反的顺序分配两个对象时，如上所示，您可能会陷入死锁。 std::lock点是为了避免这种僵局。

复制构造函数

你没有问文案成员，但我们不妨现在谈谈他们(如果不是你，有人会需要他们)。

    A(const A& a)
    {
        ReadLock  rhs_lk(a.mut_);
        field1_ = a.field1_;
        field2_ = a.field2_;
    }

复制构造函数看起来很像移动构造函数，除了 ReadLock使用别名代替 WriteLock .目前这两个别名 std::unique_lock<std::mutex>所以它真的没有任何区别。

但是在 C++14 中，您可以选择这样说:

    using MutexType = std::shared_timed_mutex;
    using ReadLock  = std::shared_lock<MutexType>;
    using WriteLock = std::unique_lock<MutexType>;

这可能是一种优化，但不是绝对的。您将必须测量以确定它是否是。但是通过这一改变，我们可以复制结构 来自 同时在多个线程中使用相同的rhs。 C++11 解决方案强制您使此类线程按顺序排列，即使 rhs 没有被修改。

复制作业

为了完整起见，这里是复制赋值运算符，在阅读其他所有内容后，它应该是不言自明的:

    A& operator=(const A& a)
    {
        if (this != &a)
        {
            WriteLock lhs_lk(mut_, std::defer_lock);
            ReadLock  rhs_lk(a.mut_, std::defer_lock);
            std::lock(lhs_lk, rhs_lk);
            field1_ = a.field1_;
            field2_ = a.field2_;
        }
        return *this;
    }

等等

访问 A 的任何其他成员或免费功能如果您希望多个线程能够同时调用它们，则也需要保护 的状态。例如，这里是 swap :

    friend void swap(A& x, A& y)
    {
        if (&x != &y)
        {
            WriteLock lhs_lk(x.mut_, std::defer_lock);
            WriteLock rhs_lk(y.mut_, std::defer_lock);
            std::lock(lhs_lk, rhs_lk);
            using std::swap;
            swap(x.field1_, y.field1_);
            swap(x.field2_, y.field2_);
        }
    }

请注意，如果您只依赖于 std::swap做这项工作，锁定将在错误的粒度，锁定和解锁三个 Action 之间 std::swap将在内部执行。

确实，想着 swap可以让您深入了解您可能需要为“线程安全”提供的 API A ，由于“锁定粒度”问题，这通常与“非线程安全”API 不同。

还要注意需要防止“自交换”。 “自我交换”应该是一个空操作。如果没有自检，一个人会递归地锁定同一个互斥锁。这也可以通过使用 std::recursive_mutex 在没有自检的情况下解决。为 MutexType .

更新

在下面的评论中，Yakk 对必须在复制和移动构造函数中默认构造东西感到非常不高兴(他有一个观点)。如果你对这个问题感觉足够强烈，以至于你愿意在它上面花费内存，你可以像这样避免它:

添加您需要的任何锁类型作为数据成员。这些成员必须出现在 protected 数据之前:

mutable MutexType mut_;
ReadLock  read_lock_;
WriteLock write_lock_;
// ... other data members ...

然后在构造函数(例如复制构造函数)中执行以下操作:

A(const A& a)
    : read_lock_(a.mut_)
    , field1_(a.field1_)
    , field2_(a.field2_)
{
    read_lock_.unlock();
}

糟糕，Yakk 在我有机会完成此更新之前删除了他的评论。但是他插入了这个问题，并为这个答案找到了解决方案，值得称赞。

更新 2

dyp 提出了这个好建议:

    A(const A& a)
        : A(a, ReadLock(a.mut_))
    {}
private:
    A(const A& a, ReadLock rhs_lk)
        : field1_(a.field1_)
        , field2_(a.field2_)
    {}