std::unique_lock::unique_lock
De cppreference.com
<tbody>
</tbody>
unique_lock() noexcept; |
(1) | (desde C++11) |
unique_lock( unique_lock&& other ) noexcept; |
(2) | (desde C++11) |
explicit unique_lock( mutex_type& m ); |
(3) | (desde C++11) |
unique_lock( mutex_type& m, std::defer_lock_t t ) noexcept; |
(4) | (desde C++11) |
unique_lock( mutex_type& m, std::try_to_lock_t t ); |
(5) | (desde C++11) |
unique_lock( mutex_type& m, std::adopt_lock_t t ); |
(6) | (desde C++11) |
template< class Rep, class Period > unique_lock( mutex_type& m, const std::chrono::duration<Rep,Period>& timeout_duration ); |
(7) | (desde C++11) |
template< class Clock, class Duration > unique_lock( mutex_type& m, const std::chrono::time_point<Clock,Duration>& timeout_time ); |
(8) | (desde C++11) |
Construye un unique_lock, bloqueando opcionalmente el mutex suplementado.
1) Construye un
unique_lock sin un mutex asociado.2) Constructor de movimiento. Inicializa el
unique_lock con el contenido de other. Deja a other sin un mutex asociado.3-8) Construye un
unique_lock con m como el mutex asociado. Además:3) Bloquea el mutex asociado llamando a
m.lock(). El comportamiento no está definido si el hilo actual ya posee el mutex, excepto cuando el mutex es recursivo.4) No bloquea el mutex asociado.
5) Intenta bloquear el mutex asociado sin bloquearse llamando a
m.try_lock(). El comportamiento no está definido si el hilo actual ya posee el mutex, excepto cuando el mutex es recursivo.6) Supone que el hilo llamante ya posee a
m.7) Intenta bloquear el mutex asociado llamando a
m.try_lock_for(timeout_duration). Se bloquea hasta que la duración del tiempo de espera timeout_duration haya transcurrido o el cerrojo se adquiera, lo que suceda primero. Puede bloquearse por un período más largo que timeout_duration.8) Intenta bloquear el mutex asociado llamando a
m.try_lock_until(timeout_time). Se bloquea hasta que se alcance el tiempo de espera timeout_time o se adquiera el cerrojo, lo que suceda primero. Puede bloquearse por un período más largo hasta que se alcance el tiempo de espera timeout_time.Parámetros
| other | - | Otro objeto unique_lock con el cual inicializar el estado.
|
| m | - | Mutex con el cual asociar el cerrojo y del cual, opcionalmente, tomar posesión. |
| t | - | Parámetro de etiqueta usado para seleccionar los constructores con distintas estrategias de bloqueo. |
| timeout_duration | - | Duración máxima a bloquearse. |
| timeout_time | - | Punto de tiempo máximo hasta el cual bloquearse. |
Ejemplo
Ejecuta este código
#include <iostream>
#include <thread>
#include <vector>
#include <mutex>
std::mutex m_a, m_b, m_c;
int a, b, c = 1;
void actualizar()
{
{ // Nota: std::lock_guard o atomic<int> pueden usarse en su lugar
std::unique_lock<std::mutex> lk(m_a);
a++;
}
{ // Nota: véase std::lock y std::scoped_lock para detalles y alternativas
std::unique_lock<std::mutex> lk_b(m_b, std::defer_lock);
std::unique_lock<std::mutex> lk_c(m_c, std::defer_lock);
std::lock(lk_b, lk_c);
b = std::exchange(c, b+c);
}
}
int main()
{
std::vector<std::thread> hilos;
for (unsigned i = 0; i < 12; ++i)
hilos.emplace_back(actualizar);
for (auto& hilo: hilos)
hilo.join();
std::cout << "Nros. Fibonacci " << a << "o y " << a+1 << "o: "
<< b << " y " << c << '\n';
}
Salida:
Nros. Fibonacci 12o y 13o: 144 y 233