通过设计,std::mutex
不可移动或复制。这意味着一个类 A
持有互斥锁不会收到默认的移动构造函数。
我将如何制作这种类型 A
以线程安全的方式移动?
最佳答案
让我们从一些代码开始:
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 对必须在复制和移动构造函数中默认构造东西感到非常不高兴(他有一个观点)。如果你对这个问题感觉足够强烈,以至于你愿意在它上面花费内存,你可以像这样避免它:
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_)
{}
关于c++ - 我应该如何处理 C++ 中可移动类型中的互斥锁?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/29986208/