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

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.

Fontes