std::defer_lock, std::try_to_lock, std::adopt_lock
De cppreference.com
<tbody>
</tbody>
<tbody class="t-dcl-rev ">
</tbody><tbody>
</tbody>
<tbody class="t-dcl-rev ">
</tbody><tbody>
</tbody>
<tbody class="t-dcl-rev ">
</tbody><tbody>
</tbody>
| Definido en el archivo de encabezado <mutex>
|
||
constexpr std::defer_lock_t defer_lock {}; |
(desde C++11) (hasta C++17) |
|
inline constexpr std::defer_lock_t defer_lock {}; |
(desde C++17) | |
constexpr std::try_to_lock_t try_to_lock {}; |
(desde C++11) (hasta C++17) |
|
inline constexpr std::try_to_lock_t try_to_lock {}; |
(desde C++17) | |
constexpr std::adopt_lock_t adopt_lock {}; |
(desde C++11) (hasta C++17) |
|
inline constexpr std::adopt_lock_t adopt_lock {}; |
(desde C++17) | |
std::defer_lock, std::try_to_lock y std::adopt_lock son instancias de tipos etiqueta struct vacíos std::defer_lock_t, std::try_to_lock_t y std::adopt_lock_t respectivamente.
Se usan para especificar las estrategias de bloqueo para std::lock_guard, std::unique_lock y std::shared_lock.
| Tipo | Efecto(s) |
defer_lock_t
|
No toman posesión del mutex |
try_to_lock_t
|
Tratan de tomar posesión del mutex sin bloquear |
adopt_lock_t
|
Supone que el hilo que llama ya tomó posesión del mutex |
Ejemplo
Ejecuta este código
#include <mutex>
#include <thread>
struct cuenta_de_banco {
explicit cuenta_de_banco(int balance) : balance(balance) {}
int balance;
std::mutex m;
};
void transferir(cuenta_de_banco &de, cuenta_de_banco &a, int cantidad)
{
// bloquear ambos mutexes sin bloqueo mutuo
std::lock(from.m, to.m);
// asegurarse que ambos mutexes ya bloqueados se desbloqueen al terminar el ámbito
std::lock_guard lock1(de.m, std::adopt_lock);
std::lock_guard lock2(a.m, std::adopt_lock);
// enfoque equivalente:
// std::unique_lock<std::mutex> lock1(de.m, std::defer_lock);
// std::unique_lock<std::mutex> lock2(a.m, std::defer_lock);
// std::lock(lock1, lock2);
de.balance -= cantidad;
a.balance += cantidad;
}
int main()
{
cuenta_de_banco mi_cuenta(100);
cuenta_de_banco tu_cuenta(50);
std::thread t1(transferir, mi_cuenta, tu_cuenta, 10);
std::thread t2(transferir, tu_cuenta, mi_cuenta, 5);
t1.join();
t2.join();
}
Véase también
(C++11)(C++11)(C++11) |
Tipo de etiqueta utilizado para especificar la estrategia de bloqueo. (clase) |
Construye un objeto lock_guard, opcionalmente bloquea el mutex dado. (función miembro pública de std::lock_guard)
| |
Construye un objeto unique_lock, y opcionalmente bloquea el mutex suplementado (es decir, toma posesión). (función miembro pública de std::unique_lock)
|