Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::lock_guard — posse do bloqueio associada ao âmbito

std::lock_guard de <mutex> gere um bloqueio segundo o princípio RAII. O construtor que recebe apenas o mutex bloqueia-o. A variante com std::adopt_lock assume a responsabilidade por um bloqueio exclusivo que a thread atual já detém, sem chamar lock(). Em ambos os casos, o destrutor desbloqueia o mutex. Um objeto com nome protege uma secção crítica durante toda a sua vida útil.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

#include <mutex>
std::lock_guard<Mutex> guard(m);
std::lock_guard<Mutex> guard(m, std::adopt_lock);

std::lock_guard<Mutex> associa a posse do bloqueio à vida útil do objeto (RAII). O construtor que recebe m chama m.lock(), e o destrutor chama m.unlock(). Ao sair do âmbito, um bloqueio adquirido com sucesso é libertado, incluindo quando se sai através de return ou durante o desenrolamento da pilha após uma exceção.

O tipo Mutex tem de cumprir os requisitos de Cpp17BasicLockable. O mutex tem de existir durante toda a vida útil do guardião; o incumprimento desta condição provoca comportamento indefinido. O guardião não pode ser copiado nem movido e não disponibiliza uma operação para desbloquear antecipadamente.

A variante com std::adopt_lock assume a responsabilidade por um bloqueio já detido, sem chamar lock(). Exige que a thread atual já detenha um bloqueio exclusivo sobre esse mutex. Dê um nome ao guardião: um objeto temporário é destruído no fim da expressão completa e, por isso, não protege as instruções seguintes.

No exemplo, ambas as threads protegem cada incremento de counter com o mesmo mutex. A leitura só ocorre após ambas as chamadas a join(), pelo que o resultado esperado é 2000, independentemente do escalonamento das threads.

Exemplos

#include <iostream>
#include <mutex>
#include <thread>

int main() {
    std::mutex m;
    int counter = 0;

    auto increment = [&] {
        for (int i = 0; i < 1000; ++i) {
            std::lock_guard<std::mutex> guard(m);
            ++counter;
        }
    };

    std::thread first(increment);
    std::thread second(increment);
    first.join();
    second.join();

    std::cout << counter << '\n';
}

Resultado

2000

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.

Fontes