Cominciamo con un po 'di codice:
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:
...
Ho inserito alcuni alias di tipo piuttosto suggestivi che non trarremo vantaggio in C ++ 11, ma diventeranno molto più utili in C ++ 14. Sii paziente, ci arriveremo.
La tua domanda si riduce a:
Come scrivo il costruttore di spostamento e l'operatore di assegnazione dello spostamento per questa classe?
Inizieremo con il costruttore di mosse.
Move Constructor
Notare che il membro mutexè stato creato mutable. A rigor di termini questo non è necessario per i membri del trasferimento, ma presumo che tu voglia anche copiare i membri. In caso contrario, non è necessario creare il mutex mutable.
Durante la costruzione A, non è necessario bloccare this->mut_. Ma devi bloccare l' mut_oggetto da cui stai costruendo (sposta o copia). Questo può essere fatto in questo modo:
A(A&& a)
{
WriteLock rhs_lk(a.mut_);
field1_ = std::move(a.field1_);
field2_ = std::move(a.field2_);
}
Notare che prima dovevamo costruire di default i membri di this, quindi assegnare loro i valori solo dopo che a.mut_è stato bloccato.
Sposta assegnazione
L'operatore di assegnazione dello spostamento è sostanzialmente più complicato perché non si sa se qualche altro thread accede a lhs o rhs dell'espressione di assegnazione. E in generale, è necessario proteggersi dal seguente scenario:
x = std::move(y);
y = std::move(x);
Ecco l'operatore di assegnazione del movimento che protegge correttamente lo scenario precedente:
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;
}
Si noti che è necessario utilizzare std::lock(m1, m2)per bloccare i due mutex, invece di bloccarli uno dopo l'altro. Se li blocchi uno dopo l'altro, quando due thread assegnano due oggetti in ordine opposto come mostrato sopra, puoi ottenere un deadlock. Il punto std::lockè evitare quella situazione di stallo.
Copia costruttore
Non hai chiesto dei membri della copia, ma potremmo anche parlarne ora (se non tu, qualcuno ne avrà bisogno).
A(const A& a)
{
ReadLock rhs_lk(a.mut_);
field1_ = a.field1_;
field2_ = a.field2_;
}
Il costruttore di copia assomiglia molto al costruttore di spostamento tranne per il fatto che l' ReadLockalias viene utilizzato al posto del WriteLock. Attualmente sono entrambi alias std::unique_lock<std::mutex>e quindi non fa davvero alcuna differenza.
Ma in C ++ 14, avrai la possibilità di dire questo:
using MutexType = std::shared_timed_mutex;
using ReadLock = std::shared_lock<MutexType>;
using WriteLock = std::unique_lock<MutexType>;
Questa potrebbe essere un'ottimizzazione, ma non definitivamente. Dovrai misurare per determinare se lo è. Ma con questa modifica, è possibile copiare il costrutto dalla stessa destra in più thread contemporaneamente. La soluzione C ++ 11 ti obbliga a rendere sequenziali tali thread, anche se le rhs non vengono modificate.
Copia compito
Per completezza, ecco l'operatore di assegnazione della copia, che dovrebbe essere abbastanza autoesplicativo dopo aver letto di tutto il resto:
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;
}
E così via.
Anche gli altri membri o funzioni libere che accedono allo Astato devono essere protetti se ci si aspetta che più thread siano in grado di chiamarli contemporaneamente. Ad esempio, ecco 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_);
}
}
Nota che se dipendi solo dal std::swapfare il lavoro, il blocco sarà con granularità sbagliata, bloccando e sbloccando tra le tre mosse che std::swapverrebbero eseguite internamente.
In effetti, pensare swappuò darti un'idea dell'API di cui potresti aver bisogno per fornire un "thread-safe" A, che in generale sarà diverso da un'API "non-thread-safe", a causa del problema della "granularità del blocco".
Notare anche la necessità di proteggersi dal "self-swap". "self-swap" dovrebbe essere un no-op. Senza l'autoverifica si bloccherebbe ricorsivamente lo stesso mutex. Questo potrebbe anche essere risolto senza l'autoverifica utilizzando std::recursive_mutexper MutexType.
Aggiornare
Nei commenti qui sotto Yakk è piuttosto scontento di dover costruire cose predefinite nei costruttori di copia e spostamento (e ha ragione). Se ti senti abbastanza forte su questo problema, tanto da essere disposto a dedicarci memoria, puoi evitarlo in questo modo:
Aggiungi qualsiasi tipo di blocco di cui hai bisogno come membri dati. Questi membri devono precedere i dati che vengono protetti:
mutable MutexType mut_;
ReadLock read_lock_;
WriteLock write_lock_;
E poi nei costruttori (ad esempio il costruttore di copie) fai questo:
A(const A& a)
: read_lock_(a.mut_)
, field1_(a.field1_)
, field2_(a.field2_)
{
read_lock_.unlock();
}
Oops, Yakk ha cancellato il suo commento prima che avessi la possibilità di completare questo aggiornamento. Ma merita credito per aver spinto questo problema e aver trovato una soluzione in questa risposta.
Aggiorna 2
E dyp ha avuto questo buon suggerimento:
A(const A& a)
: A(a, ReadLock(a.mut_))
{}
private:
A(const A& a, ReadLock rhs_lk)
: field1_(a.field1_)
, field2_(a.field2_)
{}