std::shared_timed_mutex:: try_lock_for

Versucht, den Mutex zu sperren. Blockiert bis die angegebene Dauer timeout_duration abgelaufen ist (Timeout) oder die Sperre erworben wurde (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 länger blockieren als timeout_duration aufgrund von Planungs- oder Ressourcenkonfliktverzögerungen.

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.

Wenn try_lock_for von einem Thread aufgerufen wird, der den Mutex bereits in einem beliebigen Modus (shared oder exclusive) besitzt, ist das Verhalten undefiniert.

Parameter

Rückgabewert

true wenn die Sperre erfolgreich erworben wurde, andernfalls false .

Exceptions

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

Siehe auch