C++ concepts: Mutex

The Mutex concept extends the Lockable concept to include inter-thread synchronization.

For object m of Mutex type.

Behaves as an atomic operation.
Blocks the calling thread until exclusive ownership of the mutex can be obtained.
Prior m.unlock() operations on the same mutex synchronize-with this lock operation (equivalent to release-acquire std::memory_order)
The behavior is undefined if the calling thread already owns the mutex (except if m is std::recursive_mutex or std::recursive_timed_mutex)
Exception of type std::system_error may be thrown on errors, with the following error codes:

std::errc::operation_not_permitted if the calling thread does not have required privileges
std::errc::resource_deadlock_would_occur if the implementation detects that this operation would lead to deadlock
std::errc::device_or_resource_busy if the mutex is already locked

Behaves as an atomic operation.
Attempts to obtain exclusive ownership of the mutex for the calling thread without blocking. If ownership is not obtained, returns immediately. The function is allowed to spuriously fail and return even if the mutex is not currently owned by another thread.
If try_lock() succeeds, prior unlock() operations on the same object synchronize-with this operation (equivalent to release-acquire std::memory_order). lock() does not synchronize with a failed try_lock()

Behaves as an atomic operation.
Releases the calling thread's ownership of the mutex and synchronizes-with the subsequent successful lock operations on the same object.
The behavior is undefined if the calling thread does not own the mutex.

The following standard library types satisfy Mutex:

Language
Standard library headers
Concepts
Utilities library
Strings library
Containers library
Algorithms library
Iterators library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)