Namensräume
Varianten
Aktionen

std::mutex::try_lock

Von cppreference.com
< cpp‎ | thread‎ | mutex
 
 
Bibliothek für nebenläufige Programmierung
Threads
(C++11)
(C++20)
this_thread Namespace
(C++11)
(C++11)
(C++11)
Kooperatives Beenden
Gegenseitiger Ausschluss
(C++11)
Allgemeines Sperrungsmanagement
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Bedingungsvariablen
(C++11)
Semaphoren
Latches und Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
Sichere Wiederherstellung
(C++26)
Hazard Pointer
Atomare Typen
(C++11)
(C++20)
Initialisierung von atomaren Typen
(C++11)(veraltet in C++20)
(C++11)(veraltet in C++20)
Speicherordnung
(C++11)(deprecated in C++26)
Freie Funktionen für atomare Operationen
Freie Funktionen für atomare Flags
 
std::mutex
Memberfunktionen
Sperren
mutex::try_lock
Native handle
 
bool try_lock();
(seit C++11)

Versucht, den Mutex zu sperren. Gibt sofort zurück. Bei erfolgreichem Erwerb der Sperre wird true zurückgegeben, andernfalls wird false zurückgegeben.

Diese Funktion kann fehlschlagen (spurious failure) und false zurückgeben, auch wenn der Mutex derzeit von keinem anderen Thread gesperrt ist.

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

Eine vorherige unlock()-Operation auf demselben Mutex synchronisiert mit (wie in std::memory_order definiert) dieser Operation, wenn sie true zurückgibt. Beachten Sie, dass eine vorherige lock()-Operation nicht mit dieser Operation synchronisiert, wenn sie false zurückgibt.

Inhalt

[bearbeiten] Parameter

(keine)

[bearbeiten] Rückgabewert

true, wenn die Sperre erfolgreich erworben wurde, andernfalls false.

[bearbeiten] Ausnahmen

Wirft nichts.

[bearbeiten] Beispiel

#include <chrono>
#include <iostream> // std::cout
#include <mutex>
#include <thread>
 
std::chrono::milliseconds interval(100);
 
std::mutex mutex;
int job_shared = 0; // both threads can modify 'job_shared',
                    // mutex will protect this variable
 
int job_exclusive = 0; // only one thread can modify 'job_exclusive'
                       // no protection needed
 
// this thread can modify both 'job_shared' and 'job_exclusive'
void job_1() 
{
    std::this_thread::sleep_for(interval); // let 'job_2' take a lock
 
    while (true)
    {
        // try to lock mutex to modify 'job_shared'
        if (mutex.try_lock())
        {
            std::cout << "job shared (" << job_shared << ")\n";
            mutex.unlock();
            return;
        }
        else
        {
            // can't get lock to modify 'job_shared'
            // but there is some other work to do
            ++job_exclusive;
            std::cout << "job exclusive (" << job_exclusive << ")\n";
            std::this_thread::sleep_for(interval);
        }
    }
}
 
// this thread can modify only 'job_shared'
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();
}

Mögliche Ausgabe

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

[bearbeiten] Siehe auch

sperrt den Mutex, blockiert, wenn der Mutex nicht verfügbar ist
(public member function) [edit]
entsperrt den Mutex
(public member function) [edit]
C-Dokumentation für mtx_trylock