Archivo de encabezado de la biblioteca estándar <mutex>
De cppreference.com
Este archivo de encabezado es parte de la biblioteca de soporte de hilos.
Clases | |
(C++11) |
Proporciona servicios de exclusión mutua básicos. (clase) |
(C++11) |
Proporciona un servicio de exclusión mutua que implementa bloqueo con un tiempo de espera. (clase) |
(C++11) |
Proporciona un servicio de bloqueo mutuo que puede ser bloqueado recursivamente por el mismo hilo/subproceso. (clase) |
(C++11) |
Proporciona un servicio de exclusión mutua que puede ser bloqueado recursivamente por el mismo hilo e implementa bloqueo con un tiempo de espera. (clase) |
(C++11) |
Implementa un envoltorio de propiedad de mutex estrictamente basado en un ámbito. (plantilla de clase) |
(C++11) |
Implementa un envoltorio de propiedad de mutex movible. (plantilla de clase) |
(C++17) |
Envoltorio RAII que evita bloqueo mutuo para múltiples mutex. (plantilla de clase) |
(C++11)(C++11)(C++11) |
Tipo de etiqueta utilizado para especificar la estrategia de bloqueo. (clase) |
(C++11) |
Objeto auxiliar para asegurarse que call_once invoque la función una sola vez. (clase) |
Constantes | |
(C++11)(C++11)(C++11) |
Constantes de etiqueta que se utilizan para la estrategia de bloqueo. (constante) |
Funciones | |
(C++11) |
Intenta tomar posesión de los mutex mediante llamadas repetidas a try_lock. (plantilla de función) |
(C++11) |
Bloquea los mutex especificados. Se bloquea si ninguno está disponible. (plantilla de función) |
(C++11) |
Invoca una función una sola vez inclusive si se llama desde varios hilos. (plantilla de función) |
Especialización de std::swap para unique_lock (plantilla de función) | |
Sinopsis
namespace std {
class mutex;
class recursive_mutex;
class timed_mutex;
class recursive_timed_mutex;
struct defer_lock_t { explicit defer_lock_t() = default; };
struct try_to_lock_t { explicit try_to_lock_t() = default; };
struct adopt_lock_t { explicit adopt_lock_t() = default; };
inline constexpr defer_lock_t defer_lock { };
inline constexpr try_to_lock_t try_to_lock { };
inline constexpr adopt_lock_t adopt_lock { };
template<class Mutex> class lock_guard;
template<class... MutexTypes> class scoped_lock;
template<class Mutex> class unique_lock;
template<class Mutex>
void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
template<class L1, class L2, class... L3> int try_lock(L1&, L2&, L3&...);
template<class L1, class L2, class... L3> void lock(L1&, L2&, L3&...);
struct once_flag;
template<class Callable, class... Args>
void call_once(once_flag& flag, Callable&& func, Args&&... args);
}
Clase std::mutex
namespace std {
class mutex {
public:
constexpr mutex() noexcept;
~mutex();
mutex(const mutex&) = delete;
mutex& operator=(const mutex&) = delete;
void lock();
bool try_lock();
void unlock();
using native_handle_type = /* definido por la implementación */;
native_handle_type native_handle();
};
}
Clase std::recursive_mutex
namespace std {
class recursive_mutex {
public:
recursive_mutex();
~recursive_mutex();
recursive_mutex(const recursive_mutex&) = delete;
recursive_mutex& operator=(const recursive_mutex&) = delete;
void lock();
bool try_lock() noexcept;
void unlock();
using native_handle_type = /* definido por la implementación */;
native_handle_type native_handle();
};
}
Clase std::timed_mutex
namespace std {
class timed_mutex {
public:
timed_mutex();
~timed_mutex();
timed_mutex(const timed_mutex&) = delete;
timed_mutex& operator=(const timed_mutex&) = delete;
void lock(); // bloqueo
bool try_lock();
template<class Rep, class Period>
bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
template<class Clock, class Duration>
bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
void unlock();
using native_handle_type = /* definido por la implementación */;
native_handle_type native_handle();
};
}
Clase std::recursive_timed_mutex
namespace std {
class recursive_timed_mutex {
public:
recursive_timed_mutex();
~recursive_timed_mutex();
recursive_timed_mutex(const recursive_timed_mutex&) = delete;
recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
void lock(); // bloqueo
bool try_lock() noexcept;
template<class Rep, class Period>
bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
template<class Clock, class Duration>
bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
void unlock();
using native_handle_type = /* definido por la implementación */;
native_handle_type native_handle();
};
}
Plantilla de clase std::lock_guard
namespace std {
template<class Mutex>
class lock_guard {
public:
using mutex_type = Mutex;
explicit lock_guard(mutex_type& m);
lock_guard(mutex_type& m, adopt_lock_t);
~lock_guard();
lock_guard(const lock_guard&) = delete;
lock_guard& operator=(const lock_guard&) = delete;
private:
mutex_type& pm; // solo exposición
};
}
Plantilla de clase std::scoped_lock
namespace std {
template<class... MutexTypes>
class scoped_lock {
public:
using mutex_type = Mutex; // Si MutexTypes... consiste en el tipo único Mutex
explicit scoped_lock(MutexTypes&... m);
explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
~scoped_lock();
scoped_lock(const scoped_lock&) = delete;
scoped_lock& operator=(const scoped_lock&) = delete;
private:
tuple<MutexTypes&...> pm; // solo exposición
};
}
Plantilla de clase std::unique_lock
namespace std {
template<class Mutex>
class unique_lock {
public:
using mutex_type = Mutex;
// construcción, destrucción, copia
unique_lock() noexcept;
explicit unique_lock(mutex_type& m);
unique_lock(mutex_type& m, defer_lock_t) noexcept;
unique_lock(mutex_type& m, try_to_lock_t);
unique_lock(mutex_type& m, adopt_lock_t);
template<class Clock, class Duration>
unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
template<class Rep, class Period>
unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
~unique_lock();
unique_lock(const unique_lock&) = delete;
unique_lock& operator=(const unique_lock&) = delete;
unique_lock(unique_lock&& u) noexcept;
unique_lock& operator=(unique_lock&& u);
// bloqueo
void lock();
bool try_lock();
template<class Rep, class Period>
bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
template<class Clock, class Duration>
bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
void unlock();
// modificadores
void swap(unique_lock& u) noexcept;
mutex_type* release() noexcept;
// observadores
bool owns_lock() const noexcept;
explicit operator bool () const noexcept;
mutex_type* mutex() const noexcept;
private:
mutex_type* pm; // solo exposición
bool owns; // solo exposición
};
template<class Mutex>
void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
}
Clase std::once_flag
namespace std {
struct once_flag {
constexpr once_flag() noexcept;
once_flag(const once_flag&) = delete;
once_flag& operator=(const once_flag&) = delete;
};
}