Начнем с небольшого кода:
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. Наберитесь терпения, мы доберемся туда.
Ваш вопрос сводится к следующему:
Как мне написать конструктор перемещения и оператор присваивания перемещения для этого класса?
Начнем с конструктора перемещения.
Конструктор перемещения
Обратите внимание, что член 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_блокировки.
Переместить назначение
Оператор присваивания перемещения значительно сложнее, потому что вы не знаете, обращается ли какой-либо другой поток к левой или правой стороне выражения присваивания. И вообще, вам нужно остерегаться следующего сценария:
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_;
}
Конструктор копирования очень похож на конструктор перемещения, за исключением того, 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>;
Это может быть оптимизация, но не определенно. Вам нужно будет измерить, чтобы определить, так ли это. Но с этим изменением можно копировать конструкцию из одной и той же правой руки в несколько потоков одновременно. Решение 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может дать вам представление об API, который может потребоваться для обеспечения «поточно-ориентированного» A, который в целом будет отличаться от «небезопасного для потоков» API из-за проблемы «блокирующей гранулярности».
Также обратите внимание на необходимость защиты от «самостоятельной замены». «Самостоятельная замена» не должна применяться. Без самопроверки можно было бы рекурсивно заблокировать один и тот же мьютекс. Эту проблему также можно решить без самопроверки, используя std::recursive_mutexfor MutexType.
Обновить
В комментариях ниже Якк очень недоволен тем, что ему приходится создавать объекты по умолчанию в конструкторах копирования и перемещения (и он прав). Если вы достаточно серьезно относитесь к этой проблеме, настолько, что готовы потратить на нее память, вы можете избежать этого следующим образом:
Добавьте любые типы блокировок, которые вам нужны в качестве членов данных. Эти члены должны предшествовать защищаемым данным:
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();
}
К сожалению, Якк стер свой комментарий до того, как я успел завершить это обновление. Но он заслуживает похвалы за то, что поднял эту проблему и нашел решение в этом ответе.
Обновление 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_)
{}