Maison > développement back-end > C++ > Comment puis-je rendre ma classe C avec un Mutex mobile et Thread-Safe ?

Comment puis-je rendre ma classe C avec un Mutex mobile et Thread-Safe ?

Susan Sarandon
Libérer: 2024-11-29 06:05:14
original
623 Les gens l'ont consulté

How Can I Make My C   Class with a Mutex Movable and Thread-Safe?

Gestion des mutex dans les types mobiles en C

Problème :

En raison du non- nature copiable et non mobile de std::mutex, les classes contenant des mutex manquent de constructeurs de déplacement par défaut, ce qui rend difficile la créer des types thread-safe mobiles.

Solution :

Pour obtenir une sémantique de déplacement thread-safe pour la classe A contenant un mutex, adoptez les stratégies suivantes :

Constructeur de déplacement :

A(A&& a) {
    WriteLock rhs_lk(a.mut_); // Lock the rhs mutex
    field1_ = std::move(a.field1_); // Move the data
    field2_ = std::move(a.field2_);
}
Copier après la connexion

Affectation de déplacement Opérateur :

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;
}
Copier après la connexion

Constructeur de copie :

A(const A& a) {
    ReadLock rhs_lk(a.mut_); // Lock the rhs mutex for reading
    field1_ = a.field1_; // Copy the data
    field2_ = a.field2_;
}
Copier après la connexion

Opérateur d'affectation de copie :

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;
}
Copier après la connexion

Autre Considérations :

  • Définissez un alias de type ReadLock et WriteLock pour plus de commodité.
  • N'oubliez pas de verrouiller les deux mutex à l'aide de std::lock pour l'opérateur d'affectation de déplacement afin d'éviter une impasse.
  • Envisagez d'utiliser std::shared_timed_mutex en C 14 pour permettre des lectures.
  • Protégez toutes les fonctions membres ou fonctions libres accédant à l'état interne de la classe A à l'aide des verrous mutex appropriés.
  • Si nécessaire, ajoutez des verrous membres de données pour stocker les objets ReadLock et WriteLock afin d'éviter les valeurs par défaut. construction de membres lors de la copie.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Derniers articles par auteur
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal