Comment puis-je rendre mes classes C avec des mutex non mobiles à la fois mobiles et thread-safe ?

Déplacement thread-safe avec des mutex non mobiles en C

Lorsqu'il s'agit de types mobiles, tels que std::mutex, en C la programmation thread-safe peut être difficile. Par défaut, std::mutex n'est ni mobile ni copiable, ce qui empêche la création d'objets mobiles thread-safe.

Pour rendre une classe contenant un mutex mobile et maintenir la sécurité des threads, envisagez l'approche suivante :

1. Activer la mutabilité :
Rendre le membre mutex mutable (par exemple, mutable std::mutex mut_;) pour permettre la modification lors des opérations de déplacement.

2. Move Constructor :
Verrouillez le mutex de l'objet à partir duquel vous êtes déplacé avant d'attribuer ses membres. Cela empêche la corruption des données lors d'un accès simultané.

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

3. Opérateur d'affectation de déplacement :
Protégez l'affectation de déplacement à l'aide de primitives de synchronisation. Étant donné que l'accès à partir de plusieurs threads est possible, verrouillez les mutex de gauche (lhs) et de droite (rhs) avant d'effectuer les affectations.

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

4. Membres de copie (facultatif) :
Si des membres de copie sont également requis, utilisez ReadLock (au lieu de WriteLock) pour autoriser la lecture simultanée à partir de l'objet à partir duquel la copie est effectuée.

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

5 . Considérations supplémentaires :

• Protégez les autres fonctions membres et les fonctions libres accédant à l'état de la classe avec une synchronisation appropriée pour maintenir la sécurité des threads.
• Envisagez d'utiliser std::shared_timed_mutex ou une autre synchronisation avancée tapez à optimiser pour des scénarios spécifiques dans C 14 et versions ultérieures.

En suivant ces directives, vous pouvez vous assurer que vos classes mobiles restent thread-safe même lorsque vous utilisez des mutex non mobiles.

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!