std::shared_timed_mutex

La clase shared_timed_mutex es una primitiva de sincronización que se puede utilizar para proteger datos compartidos de un acceso simultáneo por varios hilos/subprocesos. A diferencia de otros tipos mutex que facilitan el acceso exclusivo, un shared_timed_mutex tiene dos modalidades de acceso:

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

• exclusiva - solo un hilo puede poseer el mutex.

Los mutex compartidos se usan generalmente en situaciones en las que varios lectores pueden acceder al mismo recurso al mismo tiempo sin causar carreras de datos, pero solo un escritor puede hacerlo.

De manera similar a timed_mutex, shared_timed_mutex proporciona la habilidad de intentar reclamar la propiedad de un shared_timed_mutex con un tiempo de espera a través de 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 requerimientos de SharedTimedMutex y StandardLayoutType.

[editar] Funciones miembro

[editar] Ejemplo

#include <mutex>
#include <shared_mutex>
 
class R
{
    mutable std::shared_timed_mutex mut;
    /* datos */
public:
    R& operator=(const R& other)
    {
        // requiere propiedad exclusiva para escribir a *this
        std::unique_lock<std::shared_timed_mutex> lhs(mut, std::defer_lock);
        // requiere propiedad compartida para leer de other
        std::shared_lock<std::shared_timed_mutex> rhs(other.mut, std::defer_lock);
        std::lock(lhs, rhs);
        /* asignar datos */
        return *this;
    }
};
 
int main() {
    R r;
}