std:: shared_timed_mutex

La clase shared_timed_mutex es un primitivo de sincronización que puede utilizarse para proteger datos compartidos de ser accedidos simultáneamente por múltiples hilos. A diferencia de otros tipos de mutex que facilitan acceso exclusivo, un shared_timed_mutex tiene dos niveles de acceso:

• exclusive - solo un hilo puede poseer el mutex.

• shared - varios hilos pueden compartir la propiedad del mismo mutex.

Los mutex compartidos generalmente se utilizan en situaciones en las que múltiples lectores pueden acceder al mismo recurso simultáneamente sin causar carreras de datos, pero solo un escritor puede hacerlo.

De manera similar a timed_mutex , shared_timed_mutex proporciona la capacidad de intentar reclamar la propiedad de un shared_timed_mutex con un tiempo de espera mediante las funciones miembro try_lock_for() , try_lock_until() , try_lock_shared_for() , try_lock_shared_until() .

La clase shared_timed_mutex satisface todos los requisitos de SharedTimedMutex y StandardLayoutType .

Funciones miembro

Notas

Ejemplo

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