Как реализовать атомарный (потокобезопасный) и исключительный оператор глубокого копирования?

Есть две отдельные проблемы (потокобезопасность и безопасность исключений), и, кажется, лучше рассмотреть их отдельно. Чтобы конструкторы, принимающие другой объект в качестве аргумента, могли получить блокировку при инициализации элементов, необходимо в любом случае разделить элементы данных на отдельный класс: таким образом блокировка может быть получена, пока подобъект инициализируется, а класс поддерживает фактические данные. может игнорировать любые проблемы параллелизма. Таким образом, класс будет разделен на две части: class A иметь дело с проблемами параллелизма и class A_unlocked поддерживать данные. Поскольку функции-члены A_unlocked не имеют никакой защиты от параллелизма, они не должны напрямую отображаться в интерфейсе и, таким образом, A_unlocked сделан частным членом A,

Создание оператора присваивания, исключающего исключение, является простым, используя конструктор копирования. Аргумент копируется, а члены меняются местами:

A_unlocked& A_unlocked::operator= (A_unlocked const& other) {
A_unlocked(other).swap(*this);
return *this;
}

Конечно, это означает, что подходящий конструктор копирования и swap() член реализован. Работа с распределением нескольких ресурсов, например нескольких объектов, выделенных в куче, легче всего сделать, имея подходящий обработчик ресурсов для каждого из объектов. Без использования обработчиков ресурсов быстро становится очень грязно корректно очищать все ресурсы в случае возникновения исключения. В целях поддержания кучи выделенной памяти std::unique_ptr<T> (или же std::auto_ptr<T> если вы не можете использовать C ++ 2011) является подходящим выбором. Код ниже просто копирует указанные объекты, хотя нет особого смысла выделять объекты в куче, а не делать их членами. В реальном примере объекты, вероятно, реализуют clone() метод или какой-то другой механизм для создания объекта правильного типа:

class A_unlocked {
private:
std::unique_ptr<B> pb;
std::unique_ptr<C> pc;
// ...
public:
A_unlocked(/*...*/);
A_unlocked(A_unlocked const& other);
A_unlocked& operator= (A_unlocked const& other);
void swap(A_unlocked& other);
// ...
};

A_unlocked::A_unlocked(A_unlocked const& other)
: pb(new B(*other.pb))
, pc(new C(*other.pc))
{
}
void A_unlocked::swap(A_unlocked& other) {
using std::swap;
swap(this->pb, other.pb);
swap(this->pc, other.pc);
}

Для бита безопасности потока необходимо знать, что никакой другой поток не связывается с скопированным объектом. Способ сделать это — использовать мьютекс. То есть, class A выглядит примерно так:

class A {
private:
mutable std::mutex d_mutex;
A_unlocked         d_data;
public:
A(/*...*/);
A(A const& other);
A& operator= (A const& other);
// ...
};

Обратите внимание, что все члены A потребуется сделать некоторую защиту параллелизма, если объекты типа A предназначены для использования без внешней блокировки. Поскольку мьютекс, используемый для защиты от одновременного доступа, на самом деле не является частью состояния объекта, но его необходимо изменить даже при чтении состояния объекта, он сделан mutable, С этим на месте, создание конструктора копирования просто:

A::A(A const& other)
: d_data((std::unique_lock<std::mutex>(other.d_mutex), other.d_data)) {
}

Это блокирует мьютекс аргумента и делегирует конструктор копирования члена. Блокировка автоматически снимается в конце выражения, независимо от того, была ли копия успешной или выдало исключение. Строящийся объект не нуждается в блокировке, потому что другой поток еще не знает об этом объекте.

Основная логика оператора присваивания также просто делегирует базе, используя его оператор присваивания. Сложность в том, что есть два мьютекса, которые нужно заблокировать: один для объекта, которому назначается, и один для аргумента. Поскольку другой поток может назначить два объекта только противоположным образом, существует вероятность тупиковой блокировки. Удобно, стандартная библиотека C ++ обеспечивает std::lock() алгоритм, который получает блокировки соответствующим образом, чтобы избежать мертвых блокировок. Один из способов использовать этот алгоритм — перейти в разблокированный std::unique_lock<std::mutex> объекты, по одному на каждый мьютекс, который нужно получить:

A& A::operator= (A const& other) {
if (this != &other) {
std::unique_lock<std::mutex> guard_this(this->d_mutex, std::defer_lock);
std::unique_lock<std::mutex> guard_other(other.d_mutex, std::defer_lock);
std::lock(guard_this, guard_other);

*this->d_data = other.d_data;
}
return *this;
}

Если в какой-либо момент во время назначения возникает исключение, защитники блокировки освобождают мьютексы, а обработчики ресурсов освобождают любой вновь выделенный ресурс. Таким образом, вышеупомянутый подход реализует гарантию строгого исключения. Интересно, что при назначении копии необходимо выполнить проверку самопредставления, чтобы предотвратить блокировку одного и того же мьютекса дважды. Обычно я утверждаю, что необходимая проверка самопредставления является показателем того, что оператор присваивания не является безопасным для исключения, но я думаю, что приведенный выше код безопасен для исключений.

Это серьезная переписка ответа. Более ранние версии этого ответа были либо склонны к потерянному обновлению, либо к тупику. Спасибо Якку за указание на проблемы. Хотя в результате решения проблем возникает больше кода, я думаю, что каждая отдельная часть кода на самом деле проще и может быть исследована на правильность.