std::mutex

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Bibliothek für nebenläufige Programmierung

Threads thread (C++11) jthread (C++20) hardware_destructive_interference_sizehardware_constructive_interference_size (C++17)(C++17) this_thread Namespace get_id (C++11) yield (C++11) sleep_for (C++11) sleep_until (C++11) Kooperatives Beenden stop_token (C++20) inplace_stop_token (C++26) never_stop_token (C++26) stop_source (C++20) inplace_stop_source (C++26)   stop_callback (C++20) inplace_stop_callback (C++26) stop_callback_for_t (C++26) stoppable_token (C++26) unstoppable_token (C++26) stoppable-source (C++26) stoppable-callback-for (C++26)   Gegenseitiger Ausschluss mutex (C++11) recursive_mutex (C++11) shared_mutex (C++17) timed_mutex (C++11) recursive_timed_mutex (C++11) shared_timed_mutex (C++14) Allgemeines Sperrungsmanagement lock (C++11) lock_guard (C++11) scoped_lock (C++17) unique_lock (C++11) shared_lock (C++14) once_flag (C++11) call_once (C++11) try_lock (C++11) defer_locktry_to_lockadopt_lockdefer_lock_ttry_to_lock_tadopt_lock_t (C++11)(C++11)(C++11)(C++11)(C++11)(C++11) Bedingungsvariablen condition_variable (C++11) condition_variable_any (C++11) notify_all_at_thread_exit (C++11) cv_status (C++11) Semaphoren counting_semaphorebinary_semaphore (C++20)(C++20) Latches und Barriers latch (C++20) barrier (C++20) Futures promise (C++11) future (C++11) shared_future (C++11) packaged_task (C++11) async (C++11) launch (C++11) future_status (C++11) future_error (C++11) future_category (C++11) future_errc (C++11) Sichere Wiederherstellung rcu_obj_base (C++26) rcu_domain (C++26) rcu_default_domain (C++26) rcu_synchronize (C++26) rcu_barrier (C++26) rcu_retire (C++26) Hazard Pointer hazard_pointer_obj_base (C++26) hazard_pointer (C++26) make_hazard_pointer (C++26)

Atomare Typen atomic (C++11) atomic_ref (C++20) atomic_flag (C++11) Initialisierung von atomaren Typen atomic_init (C++11)(veraltet in C++20) ATOMIC_VAR_INIT (C++11)(veraltet in C++20) ATOMIC_FLAG_INIT (C++11) Speicherordnung memory_order (C++11) kill_dependency (C++11)(deprecated in C++26) atomic_thread_fence (C++11) atomic_signal_fence (C++11) Freie Funktionen für atomare Operationen atomic_storeatomic_store_explicit (C++11)(C++11) atomic_loadatomic_load_explicit (C++11)(C++11) atomic_exchangeatomic_exchange_explicit (C++11)(C++11) atomic_compare_exchange_weakatomic_compare_exchange_weak_explicitatomic_compare_exchange_strongatomic_compare_exchange_strong_explicit (C++11)(C++11)(C++11)(C++11) atomic_fetch_addatomic_fetch_add_explicit (C++11)(C++11) atomic_fetch_subatomic_fetch_sub_explicit (C++11)(C++11) atomic_fetch_andatomic_fetch_and_explicit (C++11)(C++11) atomic_fetch_oratomic_fetch_or_explicit (C++11)(C++11) atomic_fetch_xoratomic_fetch_xor_explicit (C++11)(C++11) atomic_fetch_maxatomic_fetch_max_explicit (C++26)(C++26) atomic_fetch_minatomic_fetch_min_explicit (C++26)(C++26) atomic_is_lock_free (C++11) atomic_waitatomic_wait_explicit (C++20)(C++20) atomic_notify_one (C++20) atomic_notify_all (C++20) Freie Funktionen für atomare Flags atomic_flag_test_and_setatomic_flag_test_and_set_explicit (C++11)(C++11) atomic_flag_clearatomic_flag_clear_explicit (C++11)(C++11) atomic_flag_testatomic_flag_test_explicit (C++20)(C++20) atomic_flag_waitatomic_flag_wait_explicit (C++20)(C++20) atomic_flag_notify_one (C++20) atomic_flag_notify_all (C++20)

 

std::mutex

Memberfunktionen

mutex::mutex

mutex::~mutex

Sperren

mutex::lock

mutex::try_lock

mutex::unlock

Native handle

mutex::native_handle

 

Definiert in Header <mutex>
class mutex;		(seit C++11)

Die Klasse mutex ist ein Synchronisationsprimitiv, das verwendet werden kann, um gemeinsam genutzte Daten vor dem gleichzeitigen Zugriff durch mehrere Threads zu schützen.

mutex bietet exklusive, nicht-rekursive Eigentumssemantik.

• Ein aufrufender Thread besitzt ein mutex ab dem Zeitpunkt, an dem er erfolgreich entweder lock oder try_lock aufruft, bis er unlock aufruft.
• Wenn ein Thread ein mutex besitzt, werden alle anderen Threads blockiert (bei Aufrufen von lock) oder erhalten einen Rückgabewert von false (für try_lock), wenn sie versuchen, das Eigentum an dem mutex zu beanspruchen.
• Ein aufrufender Thread darf das mutex nicht bereits besitzen, bevor er lock oder try_lock aufruft.

Das Verhalten eines Programms ist undefiniert, wenn ein mutex zerstört wird, während es noch von Threads besessen wird, oder wenn ein Thread beendet wird, während er ein mutex besitzt. Die Klasse mutex erfüllt alle Anforderungen von Mutex und StandardLayoutType.

std::mutex ist weder kopierbar noch verschiebbar.

Verschachtelte Typen

Name	Definition
native_handle_type (optional*)	implementierungsabhängig

Memberfunktionen

(Konstruktor)	konstruiert den Mutex (public member function)
(Destruktor)	zerstört den Mutex (public member function)
operator= [gelöscht]	nicht kopierbar (public member function)
Sperren
lock	sperrt den Mutex, blockiert, wenn der Mutex nicht verfügbar ist (public member function)
try_lock	versucht, den Mutex zu sperren, kehrt zurück, wenn der Mutex nicht verfügbar ist (public member function)
unlock	entsperrt den Mutex (public member function)
Native handle
native_handle	gibt das implementierungsabhängige native Handle-Objekt zurück (public member function)

Anmerkungen

std::mutex wird normalerweise nicht direkt verwendet: std::unique_lock, std::lock_guard, oder std::scoped_lock(seit C++17) verwalten das Sperren auf eine ausnahme-sicherere Weise.

Beispiel

Dieses Beispiel zeigt, wie ein mutex verwendet werden kann, um eine zwischen zwei Threads gemeinsam genutzte std::map zu schützen.

Führen Sie diesen Code aus

#include <chrono>
#include <iostream>
#include <map>
#include <mutex>
#include <string>
#include <thread>
 
std::map<std::string, std::string> g_pages;
std::mutex g_pages_mutex;
 
void save_page(const std::string& url)
{
    // simulate a long page fetch
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::string result = "fake content";
 
    std::lock_guard<std::mutex> guard(g_pages_mutex);
    g_pages[url] = result;
}
 
int main() 
{
    std::thread t1(save_page, "http://foo");
    std::thread t2(save_page, "http://bar");
    t1.join();
    t2.join();
 
    // safe to access g_pages without lock now, as the threads are joined
    for (const auto& [url, page] : g_pages)
        std::cout << url << " => " << page << '\n';
}

Ausgabe

http://bar => fake content
http://foo => fake content

Siehe auch

recursive_mutex (C++11)	bietet Gegenseitiger-Ausschluss-Funktionen, die von demselben Thread rekursiv gesperrt werden können (Klasse)
lock_guard (C++11)	implementiert einen streng bereichsbezogenen Mutex-Besitz-Wrapper (Klassen-Template)
unique_lock (C++11)	implementiert verschiebbaren Mutex-Besitz-Wrapper (Klassenvorlage)
scoped_lock (C++17)	todesfallsichere RAII-Hülle für mehrere Mutexe (Klassen-Template)
condition_variable (C++11)	bietet eine Bedingungsvariable, die mit einem std::unique_lock verbunden ist (Klasse)