std:: shared_timed_mutex

La classe shared_timed_mutex est un primitif de synchronisation qui peut être utilisé pour protéger des données partagées contre un accès simultané par plusieurs threads. Contrairement aux autres types de mutex qui facilitent l'accès exclusif, un shared_timed_mutex possède deux niveaux d'accès :

• exclusive - un seul thread peut posséder le mutex.

• shared - plusieurs threads peuvent partager la propriété du même mutex.

Les mutex partagés sont généralement utilisés dans des situations où plusieurs lecteurs peuvent accéder à la même ressource simultanément sans provoquer de courses aux données, mais un seul rédacteur peut le faire.

D'une manière similaire à timed_mutex , shared_timed_mutex offre la possibilité de tenter de revendiquer la propriété d'un shared_timed_mutex avec un délai d'attente via les fonctions membres try_lock_for() , try_lock_until() , try_lock_shared_for() , try_lock_shared_until() .

La classe shared_timed_mutex satisfait toutes les exigences de SharedTimedMutex et de StandardLayoutType .

Fonctions membres

Notes

Exemple

#include <mutex>
#include <shared_mutex>
class R
{
    mutable std::shared_timed_mutex mut;
    /* data */
public:
    R& operator=(const R& other)
    {
        // requires exclusive ownership to write to *this
        std::unique_lock<std::shared_timed_mutex> lhs(mut, std::defer_lock);
        // requires shared ownership to read from other
        std::shared_lock<std::shared_timed_mutex> rhs(other.mut, std::defer_lock);
        std::lock(lhs, rhs);
        /* assign data */
        return *this;
    }
};
int main()
{
    R r;
}