Wie erstelle ich einen beweglichen Typ mit internen Mutexes in C?

Umgang mit Mutexes in beweglichen Typen in C

Wie Sie erwähnt haben, ist std::mutex weder beweglich noch kopierbar, was eine Herausforderung darstellt, wenn Arbeiten mit Klassen, die Mutexe enthalten. Um einen Typ verschiebbar zu machen und gleichzeitig die Thread-Sicherheit aufrechtzuerhalten, ziehen Sie den folgenden Ansatz in Betracht:

Verschiebekonstruktor

Erstellen Sie einen Verschiebungskonstruktor, der den Mutex des Objekts, das von (a) verschoben wird, mithilfe eines WriteLock sperrt:

A(A&& a) {
  WriteLock rhs_lk(a.mut_);
  field1_ = std::move(a.field1_);
  field2_ = std::move(a.field2_);
}

Verschiebezuweisung

Der Verschiebungszuweisungsoperator ist schwieriger, da möglicherweise andere Threads darauf zugreifen entweder die linke oder die rechte Seite der Zuweisung:

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;
}

Kopierkonstruktor

Wenn Sie die Kopiersemantik unterstützen müssen, erstellen Sie einen Kopierkonstruktor, der den Mutex des Objekts sperrt, von dem kopiert wird (a ) mit einem ReadLock:

A(const A& a) {
  ReadLock rhs_lk(a.mut_);
  field1_ = a.field1_;
  field2_ = a.field2_;
}

Aufgabe kopieren

Wenn Sie auch eine Kopieraufgabe benötigen Operator, folgen Sie einem ähnlichen Muster:

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;
}

Zusätzliche Hinweise

Der Schutz von Mitgliedern und freien Funktionen, die auf den Status der Klasse zugreifen, ist für die Thread-Sicherheit von entscheidender Bedeutung. Hier ist zum Beispiel eine Swap-Funktion:

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_);
  }
}

Zuletzt erinnern wir uns daran, dass std::shared_timed_mutex in C 14 mögliche Optimierungen in Situationen ermöglicht, in denen mehrere Threads versuchen, aus demselben Objekt eine Kopie zu erstellen.

Das obige ist der detaillierte Inhalt vonWie erstelle ich einen beweglichen Typ mit internen Mutexes in C?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!