std::timed_mutex:: try_lock_for

Tente de verrouiller le mutex. Bloque jusqu'à ce que la durée spécifiée timeout_duration se soit écoulée (timeout) ou que le verrou soit acquis (le mutex est possédé), selon la première éventualité. Retourne true en cas de succès de l'acquisition du verrou, sinon retourne false .

Si timeout_duration est inférieur ou égal à timeout_duration. zero ( ) , la fonction se comporte comme try_lock() .

Cette fonction peut se bloquer plus longtemps que timeout_duration en raison de délais de planification ou de conflits de ressources.

La norme recommande qu'une std::steady_clock soit utilisée pour mesurer la durée. Si une implémentation utilise une std::system_clock à la place, le temps d'attente peut également être sensible aux ajustements d'horloge.

Comme pour try_lock() , cette fonction peut échouer de manière sporadique et renvoyer false même si le mutex n'était verrouillé par aucun autre thread à un moment donné pendant timeout_duration .

L'opération de unlock() antérieure sur le même mutex synchronise-avec (tel que défini dans std::memory_order ) cette opération si elle retourne true .

Si try_lock_for est appelé par un thread qui possède déjà le mutex, le comportement est indéfini.

Paramètres

Valeur de retour

true si le verrou a été acquis avec succès, sinon false .

Exceptions

Toute exception levée par timeout_duration (les durées fournies par la bibliothèque standard ne lèvent jamais d'exception).

Exemple

#include <chrono>
#include <iostream>
#include <mutex>
#include <sstream>
#include <thread>
#include <vector>
using namespace std::chrono_literals;
std::mutex cout_mutex; // contrôle l'accès à 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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi