The mutex class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads.

mutex offers exclusive, non-recursive ownership semantics:

• A calling thread owns a mutex from the time that it successfully calls either lock or try_lock until it calls unlock .
• When a thread owns a mutex , all other threads will block (for calls to lock ) or receive a false return value (for try_lock ) if they attempt to claim ownership of the mutex .
• A calling thread must not own the mutex prior to calling lock or try_lock .

  The behavior of a program is undefined if a mutex is destroyed while still owned by any threads, or a thread terminates while owning a mutex . The mutex class satisfies all requirements of Mutex and StandardLayoutType .

  std::mutex is neither copyable nor movable.

  Contents 1 Nested types 2 Member functions 2.1 Locking 2.2 Native handle 3 Notes 4 Example 5 See also [ edit ] Nested types

  Definition

  native_handle

  returns the underlying implementation-defined native handle object (public member function) [edit] [ edit ] Notes std::mutex is usually not accessed directly: std::unique_lock , std::lock_guard , or std::scoped_lock (since C++17) manage locking in a more exception-safe manner. [ edit ] Example This example shows how a mutex can be used to protect an std::map shared between two threads. Run this code #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'; Output: http://bar => fake content http://foo => fake content [edit] See also

  recursive_mutex (C++11)

  provides mutual exclusion facility which can be locked recursively by the same thread (class) [edit]

  lock_guard (C++11)

  implements a strictly scope-based mutex ownership wrapper (class template) [edit]

  unique_lock (C++11)

  implements movable mutex ownership wrapper (class template) [edit]

  scoped_lock (C++17)

  deadlock-avoiding RAII wrapper for multiple mutexes (class template) [edit]

  condition_variable (C++11)

  provides a condition variable associated with a std::unique_lock (class) [edit] Toolbox What links here Related changes Upload file Special pages Printable version Permanent link Page information In other languages العربية Deutsch Español Français Italiano 日本語 한국어 Português Русский 中文 This page was last modified on 6 March 2024, at 18:53. This page has been accessed 2,066,189 times. Privacy policy About cppreference.com Disclaimers