std::scoped_lock
De cppreference.com
<tbody>
</tbody>
| Definido en el archivo de encabezado <mutex>
|
||
template< class... MutexTypes > class scoped_lock; |
(desde C++17) | |
La clase scoped_lock es una envoltura de mutex que proporciona un mecanismo conveniente estilo RAII para poseer uno o más mutexes durante la duración del ámbito de un bloque.
Cuando se crea un objeto scoped_lock, intenta tomar posesión de los mutexes que se le asignan. Cuando el control abandona el ámbito en el que se creó el objeto scoped_lock, el scoped_lock se destruye y los mutexes se liberan, en orden inverso. Si se dan varios mutexes, el algoritmo de evitación de interbloqueo se usa como si lo hiciera std::lock.
La clase scoped_lock no se puede copiar.
Parámetros de plantilla
| MutexTypes | - | Los tipos de los mutexes a bloquear. Los tipos deben cumplir con los requerimientos de Lockable a menos que sizeof...(MutexTypes)==1, en cuyo caso el tipo único debe cumplir con los requerimientos de BasicLockable
|
Tipos miembro
| Tipo miembro | Definición |
mutex_type (if sizeof...(MutexTypes)==1)
|
Mutex, el único tipo en MutexTypes...
|
Funciones miembro
Construye un objeto scoped_lock, opcionalmente bloqueando los mutexes dados (función miembro pública) | |
Destruye el objeto scoped_lock object, desbloquea los mutexes subyacentes (función miembro pública) | |
operator= [eliminada] |
No es asignable por copia (función miembro pública) |
Ejemplo
El siguiente ejemplo utiliza std::scoped_lock para bloquear pares de mutexes sin bloqueo mutuo y es estilo RAII.
Ejecuta este código
#include <mutex>
#include <thread>
#include <iostream>
#include <vector>
#include <functional>
#include <chrono>
#include <string>
struct Employee {
Employee(std::string id) : id(id) {}
std::string id;
std::vector<std::string> lunch_partners;
std::mutex m;
std::string output() const
{
std::string ret = "Empleado " + id + " tiene compañeros de almuerzo: ";
for( const auto& partner : lunch_partners )
ret += partner + " ";
return ret;
}
};
void send_mail(Employee &, Employee &)
{
// simular una operación de mensajeo que consume tiempo
std::this_thread::sleep_for(std::chrono::seconds(1));
}
void assign_lunch_partner(Employee &e1, Employee &e2)
{
static std::mutex io_mutex;
{
std::lock_guard<std::mutex> lk(io_mutex);
std::cout << e1.id << " y " << e2.id << " a la espera de cerrojos" << std::endl;
}
{
// usar std::scoped_lock para adquirir dos cerrojos sin preocuparse deabout
// otras llamadas a assign_lunch_partner interbloquándonos
// y también proporciona un mecanismo estilo RAII conveniente
std::scoped_lock lock(e1.m, e2.m);
// Código equivalente 1 (usando std::lock y std::lock_guard)
// std::lock(e1.m, e2.m);
// std::lock_guard<std::mutex> lk1(e1.m, std::adopt_lock);
// std::lock_guard<std::mutex> lk2(e2.m, std::adopt_lock);
// Código equivalente 2 (si se necesirtan unique_locks, p. ej., para variables de condición)
// std::unique_lock<std::mutex> lk1(e1.m, std::defer_lock);
// std::unique_lock<std::mutex> lk2(e2.m, std::defer_lock);
// std::lock(lk1, lk2);
{
std::lock_guard<std::mutex> lk(io_mutex);
std::cout << e1.id << " y " << e2.id << " adquirieron cerrojos" << std::endl;
}
e1.lunch_partners.push_back(e2.id);
e2.lunch_partners.push_back(e1.id);
}
send_mail(e1, e2);
send_mail(e2, e1);
}
int main()
{
Employee alice("alice"), bob("bob"), christina("christina"), dave("dave");
// asignar en hilos paralelos porque enviar correo a los usuarios
// sobre sus compañeros asignados se lleva mucho tiempo
std::vector<std::thread> threads;
threads.emplace_back(assign_lunch_partner, std::ref(alice), std::ref(bob));
threads.emplace_back(assign_lunch_partner, std::ref(christina), std::ref(bob));
threads.emplace_back(assign_lunch_partner, std::ref(christina), std::ref(alice));
threads.emplace_back(assign_lunch_partner, std::ref(dave), std::ref(bob));
for (auto &thread : threads) thread.join();
std::cout << alice.output() << '\n' << bob.output() << '\n'
<< christina.output() << '\n' << dave.output() << '\n';
}
Posible salida:
alice y bob a la espera de cerrojos
alice y bob adquirieron cerrojos
christina y bob a la espera de cerrojos
christina y alice a la espera de cerrojos
dave y bob a la espera de cerrojos
dave y bob adquirieron cerrojos
christina y alice adquirieron cerrojos
christina y bob adquirieron cerrojos
Empleado alice tiene compañeros de almuerzo: bob christina
Empleado bob tiene compañeros de almuerzo: alice dave christina
Empleado christina tiene compañeros de almuerzo: alice bob
Empleado dave tiene compañeros de almuerzo: bob
Informes de defectos
Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.
| ID | Aplicado a | Comportamiento según lo publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 2981 | C++17 | Se proporcionó guía de deducción redundante de scoped_lock<MutexTypes...>.
|
Se eliminó. |
Véase también
(C++11) |
Implementa un envoltorio de propiedad de mutex movible. (plantilla de clase) |
(C++11) |
Implementa un envoltorio de propiedad de mutex estrictamente basado en un ámbito. (plantilla de clase) |