std::recursive_timed_mutex:: try_lock_for

Versucht, den Mutex zu sperren. Blockiert bis die angegebene Dauer timeout_duration abgelaufen ist (Timeout) oder die Sperre erworben wird (den Mutex besitzt), je nachdem, was zuerst eintritt. Bei erfolgreichem Sperrenrwerb wird true zurückgegeben, andernfalls false .

Wenn timeout_duration kleiner oder gleich timeout_duration. zero ( ) ist, verhält sich die Funktion wie try_lock() .

Diese Funktion kann aufgrund von Planungs- oder Ressourcenkonflikten länger blockieren als timeout_duration .

Der Standard empfiehlt, dass eine std::steady_clock zur Messung der Dauer verwendet wird. Falls eine Implementierung stattdessen eine std::system_clock verwendet, kann die Wartezeit auch anfällig für Uhr-Anpassungen sein.

Wie bei try_lock() ist es dieser Funktion erlaubt, fälschlicherweise zu scheitern und false zurückzugeben, selbst wenn das Mutex zu keinem Zeitpunkt während der timeout_duration durch einen anderen Thread gesperrt war.

Ein vorheriger unlock() -Vorgang auf demselben Mutex synchronisiert-mit (wie definiert in std::memory_order ) diesem Vorgang, falls er true zurückgibt.

Ein Thread kann try_lock_for auf einem rekursiven Mutex wiederholt aufrufen. Erfolgreiche Aufrufe von try_lock_for erhöhen den Besitzzähler: Der Mutex wird erst freigegeben, nachdem der Thread eine entsprechende Anzahl von Aufrufen von unlock() durchgeführt hat.

Die maximale Anzahl der Eigentümerebenen ist nicht spezifiziert. Ein Aufruf von try_lock_for gibt false zurück, wenn diese Anzahl überschritten wird.

Parameter

Rückgabewert

true wenn die Sperre erfolgreich erworben wurde, andernfalls false .

Ausnahmen

Jede Ausnahme, die von timeout_duration geworfen wird (von der Standardbibliothek bereitgestellte Dauern werfen niemals Ausnahmen).

Beispiel

#include <chrono>
#include <iostream>
#include <mutex>
#include <sstream>
#include <thread>
#include <vector>
using namespace std::chrono_literals;
std::mutex cout_mutex; // Zugriff auf std::cout steuern
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

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch