Comment implémenter la sémantique de déplacement Thread-Safe pour les classes contenant des mutex ?

Sémantique de déplacement thread-safe pour les objets contenant des mutex

Problème :

Mutex de bibliothèque standard (std::mutex) ne sont ni copiables ni mobiles, ce qui conduit à l'absence de constructeurs de déplacement par défaut pour les classes contenant des mutex. Cela pose un défi pour réaliser des types mobiles de manière thread-safe.

Solution :

Pour rendre une classe contenant un mutex mobile tout en garantissant la sécurité des threads, ce qui suit des mesures peuvent être prises :

class A
{
    using MutexType = std::mutex;
    using ReadLock = std::unique_lock<MutexType>;
    using WriteLock = std::unique_lock<MutexType>;

    mutable MutexType mut_;
    // Other member variables...
};

Déménager Constructeur :

A(A&& a)
{
    WriteLock rhs_lk(a.mut_);
    // Copy or move member variables under rhs_lk protection.
}

Déplacer l'affectation :

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);
        // Copy or move member variables under combined lock.
    }
    return *this;
}

Copier le constructeur :

A(const A& a)
{
    ReadLock rhs_lk(a.mut_);
    // Copy member variables under rhs_lk protection.
}

Copier Affectation :

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);
        // Copy member variables under combined lock.
    }
    return *this;
}

Ces opérations de déplacement et de copie sécurisées pour les threads préservent l'intégrité du mutex et permettent une modification et un accès fiables aux variables membres sous protection de verrouillage.

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!