std::mutex:: try_lock

Versucht, den Mutex zu sperren. Gibt sofort zurück. Bei erfolgreichem Sperren gibt true zurück, andernfalls wird false zurückgegeben.

Diese Funktion kann sporadisch fehlschlagen und false zurückgeben, selbst wenn das Mutex derzeit von keinem anderen Thread gesperrt ist.

Wenn try_lock von einem Thread aufgerufen wird, der bereits den mutex besitzt, ist das Verhalten undefiniert.

Ein vorheriger unlock() -Vorgang auf demselben Mutex synchronisiert-mit (wie definiert in std::memory_order ) diesem Vorgang, falls er true zurückgibt. Beachten Sie, dass ein vorheriger lock() -Vorgang nicht mit diesem Vorgang synchronisiert, falls er false zurückgibt.

Parameter

(keine)

Rückgabewert

true wenn die Sperre erfolgreich erworben wurde, andernfalls false .

Ausnahmen

Wirft nichts.

Beispiel

#include <chrono>
#include <iostream> // std::cout
#include <mutex>
#include <thread>
std::chrono::milliseconds interval(100);
std::mutex mutex;
int job_shared = 0; // beide Threads können 'job_shared' modifizieren,
                    // mutex schützt diese Variable
int job_exclusive = 0; // nur ein Thread kann 'job_exclusive' modifizieren
                       // kein Schutz benötigt
// dieser Thread kann sowohl 'job_shared' als auch 'job_exclusive' modifizieren
void job_1() 
{
    std::this_thread::sleep_for(interval); // lasse 'job_2' eine Sperre übernehmen
    while (true)
    {
        // versuche Mutex zu sperren um 'job_shared' zu modifizieren
        if (mutex.try_lock())
        {
            std::cout << "job shared (" << job_shared << ")\n";
            mutex.unlock();
            return;
        }
        else
        {
            // kann keine Sperre zum Modifizieren von 'job_shared' erhalten
            // aber es gibt andere Arbeit zu erledigen
            ++job_exclusive;
            std::cout << "job exclusive (" << job_exclusive << ")\n";
            std::this_thread::sleep_for(interval);
        }
    }
}
// dieser Thread kann nur 'job_shared' modifizieren
void job_2() 
{
    mutex.lock();
    std::this_thread::sleep_for(5 * interval);
    ++job_shared;
    mutex.unlock();
}
int main() 
{
    std::thread thread_1(job_1);
    std::thread thread_2(job_2);
    thread_1.join();
    thread_2.join();
}

job exclusive (1)
job exclusive (2)
job exclusive (3)
job exclusive (4)
job shared (1)

Siehe auch