让我们从一些代码开始：
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中变得更加有用。请耐心等待，我们会到达的。
您的问题可以归结为：
如何为此类编写move构造函数和move赋值运算符？
我们将从move构造函数开始。
移动构造函数
请注意，该成员mutex已创建mutable。严格来说，这对于move成员来说不是必需的，但是我假设您还需要复制成员。如果不是这种情况，则无需制作互斥体mutable。
构造时A，不需要锁定this->mut_。但是，您确实需要锁定mut_要从中构造对象的（移动或复制）。可以这样完成：
A(A&& a)
{
WriteLock rhs_lk(a.mut_);
field1_ = std::move(a.field1_);
field2_ = std::move(a.field2_);
}
请注意，我们必须默认构造thisfirst的成员，然后仅在a.mut_锁定后才为其分配值。
移动分配
移动赋值运算符实际上要复杂得多，因为您不知道是否有其他线程正在访问赋值表达式的lhs或rhs。通常，您需要注意以下情况：
x = std::move(y);
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_;
}
复制构造函数看起来与move构造函数非常相似，只不过使用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复制构造。即使未修改rhs，C ++ 11解决方案也会迫使您将此类线程顺序化。
复制作业
为了完整起见，这是副本赋值运算符，在阅读了其他所有内容后，它应该很容易解释：
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完成工作，锁定将使用错误的粒度，即std::swap内部执行的三个动作之间的锁定和解锁。
确实，考虑swap可以使您深入了解可能需要提供“线程A安全”的API，由于“锁定粒度”问题，通常与“非线程安全” API有所不同。
还要注意需要防止“自我交换”。“自我交换”应该是禁止操作的。没有自检，将递归锁定同一互斥锁。如果没有使用std::recursive_mutexfor进行自我检查，也可以解决此问题MutexType。
更新资料
在下面的评论中，Yakk对于必须默认在副本中构造事物并移动构造函数（他有观点）感到非常不满。如果您对这个问题有足够的信心，以至于您愿意花时间在它上面，那么可以这样避免：
添加您需要的任何锁类型作为数据成员。这些成员必须位于受保护的数据之前：
mutable MutexType mut_;
ReadLock read_lock_;
WriteLock write_lock_;
然后在构造函数（例如，复制构造函数）中执行以下操作：
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_)
{}