Mutexes
Concurrency
Collaboration diagram for Mutexes:

## Classes

struct | std::adopt_lock_t
struct | std::defer_lock_t
class | std::lock_guard< _Mutex >
class | std::mutex
struct | std::once_flag
class | std::recursive_mutex
class | std::recursive_timed_mutex
class | std::scoped_lock< _MutexTypes >
class | std::shared_lock< _Mutex >
class | std::shared_mutex
class | std::shared_timed_mutex
class | std::timed_mutex
struct | std::try_to_lock_t
class | std::unique_lock< _Mutex >

## Macros

#define | __cpp_lib_scoped_lock
#define | __cpp_lib_shared_mutex
#define | __cpp_lib_shared_timed_mutex

## Functions

void | std::__once_proxy (void)
template<typename _Callable , typename... _Args>
void | std::call_once (once_flag &__once, _Callable &&__f, _Args &&... __args)
template<typename _L1 , typename _L2 , typename... _L3>
void | std::lock (_L1 &__l1, _L2 &__l2, _L3 &... __l3)
template<typename _Mutex >
void | swap (shared_lock< _Mutex > &__x, shared_lock< _Mutex > &__y) noexcept
template<typename _Lock1 , typename _Lock2 , typename... _Lock3>
int | std::try_lock (_Lock1 &__l1, _Lock2 &__l2, _Lock3 &... __l3)

## Variables

constexpr adopt_lock_t | std::adopt_lock
constexpr defer_lock_t | std::defer_lock
constexpr try_to_lock_t | std::try_to_lock

## Detailed Description

Classes for mutex support.

## Macro Definition Documentation

## __cpp_lib_scoped_lock

#define __cpp_lib_scoped_lock

Definition at line 609 of file mutex.

## __cpp_lib_shared_mutex

#define __cpp_lib_shared_mutex

Definition at line 57 of file shared_mutex.

## __cpp_lib_shared_timed_mutex

#define __cpp_lib_shared_timed_mutex

Definition at line 61 of file shared_mutex.

## Function Documentation

## call_once()

template<typename _Callable , typename... _Args>

void std::call_once | ( | once_flag & | __once,
|  | _Callable && | __f,
|  | _Args &&... | __args
| ) |  |

Invoke a callable and synchronize with other calls using the same flag.

Definition at line 772 of file mutex.

## lock()

template<typename _L1 , typename _L2 , typename... _L3>

void std::lock | ( | _L1 & | __l1,
|  | _L2 & | __l2,
|  | _L3 &... | __l3
| ) |  |

Generic lock.

Parameters

  __l1 | Meets Lockable requirements (try_lock() may throw).
  __l2 | Meets Lockable requirements (try_lock() may throw).
  __l3 | Meets Lockable requirements (try_lock() may throw).

Exceptions

  An | exception thrown by an argument's lock() or try_lock() member.

Postcondition
  All arguments are locked.

All arguments are locked via a sequence of calls to lock(), try_lock() and unlock(). If the call exits via an exception any locks that were obtained will be released.

Definition at line 591 of file mutex.

## swap()

template<typename _Mutex >

void swap | ( | shared_lock< _Mutex > & | __x,
|  | shared_lock< _Mutex > & | __y
| ) |  |

related

Swap specialization for shared_lock.

Definition at line 851 of file shared_mutex.

## try_lock()

template<typename _Lock1 , typename _Lock2 , typename... _Lock3>

int std::try_lock | ( | _Lock1 & | __l1,
|  | _Lock2 & | __l2,
|  | _Lock3 &... | __l3
| ) |  |

Generic try_lock.

Parameters

  __l1 | Meets Lockable requirements (try_lock() may throw).
  __l2 | Meets Lockable requirements (try_lock() may throw).
  __l3 | Meets Lockable requirements (try_lock() may throw).

Returns
  Returns -1 if all try_lock() calls return true. Otherwise returns a 0-based index corresponding to the argument that returned false.

Postcondition
  Either all arguments are locked, or none will be.

Sequentially calls try_lock() on each argument.

Definition at line 570 of file mutex.

## Variable Documentation

## adopt_lock

constexpr adopt_lock_t std::adopt_lock

inline constexpr

Tag used to make a scoped lock take ownership of a locked mutex.

Definition at line 215 of file std_mutex.h.

## defer_lock

constexpr defer_lock_t std::defer_lock

inline constexpr

Tag used to prevent a scoped lock from acquiring ownership of a mutex.

Definition at line 209 of file std_mutex.h.

## try_to_lock

constexpr try_to_lock_t std::try_to_lock

inline constexpr

Tag used to prevent a scoped lock from blocking if a mutex is locked.

Definition at line 212 of file std_mutex.h.