CKTIS / C++
std::scoped_lock — posse de bloqueios associada ao âmbito
std::scoped_lock detém os bloqueios dos mutex durante o tempo de vida do objeto. O construtor bloqueia os mutex indicados e o destrutor desbloqueia-os. Para vários mutex, usa std::lock para evitar deadlocks durante a sua aquisição conjunta.
Versão: C++23; repository compiler flag, production runtime not attested
Sintaxe
#include <mutex>
{
std::scoped_lock guard(m1, m2);
}
{
std::lock(m1, m2);
std::scoped_lock adopted(std::adopt_lock, m1, m2);
}std::scoped_lock, de <mutex>, é um guardião RAII: associa a posse dos bloqueios ao tempo de vida de um objeto com nome. O destrutor chama unlock() para cada mutex, incluindo quando uma exceção provoca a saída do âmbito. O guardião não pode ser copiado nem movido; os mutex têm de permanecer vivos durante todo o seu tempo de vida.
O construtor normal não bloqueia nada com zero mutex, chama lock() com um mutex e usa std::lock com vários mutex. Um tipo de mutex tem de cumprir Cpp17BasicLockable; quando há vários tipos de mutex, estes têm de cumprir Cpp17Lockable. O algoritmo evita deadlocks ao adquirir esses bloqueios em conjunto, mas não impede todos os deadlocks num programa. Se a aquisição através de std::lock lançar uma exceção, essa chamada liberta os bloqueios que adquiriu antes de propagar a exceção.
A sobrecarga com std::adopt_lock não bloqueia os mutex: assume a responsabilidade de os desbloquear. A thread que a chama já tem de deter um bloqueio exclusivo sobre cada um. Não uses o construtor normal para voltar a bloquear um std::mutex já detido. Dá um nome ao guardião: o objeto temporário em std::scoped_lock{m1, m2}; é destruído no fim dessa instrução.
O exemplo atualiza dois valores enquanto detém ambos os bloqueios e apresenta 7 23 depois de os libertar. Usa deliberadamente uma única thread para produzir um resultado determinístico; não demonstra contenção entre threads. Num programa concorrente, todos os acessos aos mesmos dados protegidos têm de seguir um protocolo de sincronização coerente.
Exemplos
#include <iostream>
#include <mutex>
int main() {
std::mutex left_mutex;
std::mutex right_mutex;
int left = 10;
int right = 20;
{
std::scoped_lock guard(left_mutex, right_mutex);
left -= 3;
right += 3;
}
std::cout << left << ' ' << right << '\n';
}
Resultado
7 23
O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.