std::recursive_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 .

Un thread peut appeler try_lock_for de manière répétée sur un mutex récursif. Les appels réussis à try_lock_for incrémentent le compteur de propriété : le mutex ne sera libéré qu'après que le thread ait effectué un nombre correspondant d'appels à unlock() .

Le nombre maximum de niveaux de propriété n'est pas spécifié. Un appel à try_lock_for retournera false si ce nombre est dépassé.

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