std::shared_timed_mutex:: try_lock_for

Intenta bloquear el mutex. Se bloquea hasta que transcurra la duración especificada timeout_duration (tiempo de espera) o se adquiera el bloqueo (posee el mutex), lo que ocurra primero. Si la adquisición del bloqueo es exitosa devuelve true , en caso contrario devuelve false .

Si timeout_duration es menor o igual a timeout_duration. zero ( ) , la función se comporta como try_lock() .

Esta función puede bloquearse por más tiempo que timeout_duration debido a demoras de planificación o contención de recursos.

El estándar recomienda que se utilice un std::steady_clock para medir la duración. Si una implementación utiliza un std::system_clock en su lugar, el tiempo de espera también puede ser sensible a los ajustes del reloj.

Al igual que con try_lock() , se permite que esta función falle espuriamente y devuelva false incluso si el mutex no estaba bloqueado por ningún otro hilo en algún momento durante timeout_duration .

La operación unlock() previa sobre el mismo mutex sincroniza-con (como se define en std::memory_order ) esta operación si retorna true .

Si try_lock_for es llamado por un hilo que ya posee el mutex en cualquier modo (compartido o exclusivo), el comportamiento es indefinido.

Parámetros

Valor de retorno

true si el bloqueo fue adquirido exitosamente, de lo contrario false .

Excepciones

Cualquier excepción lanzada por timeout_duration (las duraciones proporcionadas por la biblioteca estándar nunca lanzan excepciones).

Ejemplo

#include <chrono>
#include <iostream>
#include <mutex>
#include <sstream>
#include <thread>
#include <vector>
using namespace std::chrono_literals;
std::mutex cout_mutex; // control access to std::cout
std::timed_mutex mutex;
void job(int id)
{
    std::ostringstream stream;
    for (int i = 0; i < 3; ++i)
    {
        if (mutex.try_lock_for(100ms))
        {
            stream << "success ";
            std::this_thread::sleep_for(100ms);
            mutex.unlock();
        }
        else
            stream << "failed ";
        std::this_thread::sleep_for(100ms);
    }
    std::lock_guard<std::mutex> lock{cout_mutex};
    std::cout << '[' << id << "] " << stream.str() << '\n';
}
int main()
{
    std::vector<std::thread> threads;
    for (int i{0}; i < 4; ++i)
        threads.emplace_back(job, i);
    for (auto& th : threads)
        th.join();
}

[0] failed failed failed 
[3] failed failed success 
[2] failed success failed 
[1] success failed success

Véase también