CKTIS / C++
std::unique_lock — gestão flexível de bloqueios de mutex
std::unique_lock é um objeto RAII movível, mas não copiável, de <mutex>, que gere a posse do bloqueio de um mutex. Permite adiar o bloqueio, desbloquear antes de sair do âmbito e voltar a bloquear. O destrutor desbloqueia o mutex apenas se o objeto ainda possuir o bloqueio.
Versão: C++23; repository compiler flag, production runtime not attested
Sintaxe
#include <mutex>
std::unique_lock<Mutex> lock(mutex);
std::unique_lock<Mutex> lock(mutex, std::defer_lock);std::unique_lock<Mutex> de <mutex> gere a posse do bloqueio, não o tempo de vida do mutex. Usa RAII: se o objeto possuir o bloqueio, o seu destrutor chama unlock() no mutex, incluindo quando uma exceção provoca a saída do âmbito. O mutex tem de continuar válido enquanto o objeto estiver associado a ele. O objeto pode ser movido, mas não copiado.
A construção apenas com um mutex chama o respetivo lock(). A etiqueta std::defer_lock estabelece uma associação sem bloquear; std::try_to_lock faz uma tentativa não bloqueante, cujo resultado pode verificar com owns_lock() ou convertendo para bool. std::adopt_lock exige que a thread atual já possua um bloqueio exclusivo do mutex; não é uma forma de adquirir esse bloqueio.
lock() e unlock() permitem alterar o estado antes de sair do âmbito. Não chame lock() quando o objeto já possuir o bloqueio, nem unlock() quando não o possuir. Mutex tem de cumprir os requisitos de BasicLockable; as operações de tentativa de bloqueio exigem também Lockable, enquanto try_lock_for() e try_lock_until() exigem TimedLockable. Usar std::unique_lock não acrescenta, por si só, suporte a limites de tempo a um mutex.
Não confunda release() com unlock(): release() devolve o apontador para o mutex e remove a associação, mas não desbloqueia o mutex. A responsabilidade por qualquer desbloqueio necessário passa para o código chamador. O exemplo mostra o bloqueio adiado, o desbloqueio explícito e um novo bloqueio, após o qual o destrutor liberta o bloqueio. Uma única thread torna a saída determinística; o exemplo não demonstra contenção entre threads.
Exemplos
#include <iostream>
#include <mutex>
int main() {
std::mutex mutex;
int value = 0;
{
std::unique_lock<std::mutex> lock(mutex, std::defer_lock);
std::cout << std::boolalpha << lock.owns_lock() << '\n';
lock.lock();
++value;
std::cout << lock.owns_lock() << ' ' << value << '\n';
lock.unlock();
std::cout << lock.owns_lock() << '\n';
lock.lock();
}
std::cout << value << '\n';
}
Resultado
false true 1 false 1
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.