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

CKTIS / C++

std::mutex — exclusão mútua entre threads

std::mutex, de <mutex>, permite que apenas uma thread de cada vez possua o bloqueio. Protege dados partilhados quando todos os acessos em conflito seguem o mesmo protocolo de bloqueio. std::lock_guard gere a libertação do bloqueio dentro de um âmbito.

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

Sintaxe

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

std::mutex, de <mutex>, proporciona a posse exclusiva e não recursiva de um bloqueio. Uma secção crítica é o código executado enquanto se detém esse bloqueio. Um mutex não protege automaticamente os dados: todos os acessos que possam entrar em conflito têm de seguir o mesmo protocolo de sincronização.

lock() espera para adquirir o bloqueio. try_lock() não espera e indica se teve sucesso; pode devolver false mesmo que o mutex esteja disponível. unlock() liberta o bloqueio e só pode ser chamado por quem o detém. A libertação sincroniza-se com uma aquisição posterior bem-sucedida do mesmo mutex, tornando visíveis as escritas anteriores.

Prefira um objeto com nome std::lock_guard<std::mutex>: o seu construtor bloqueia o mutex e o destrutor desbloqueia-o, incluindo quando uma exceção provoca a saída do âmbito. O mutex tem de existir durante mais tempo do que o guardião. Não tente voltar a adquirir um std::mutex que já detém; não suporta recursividade. Não pode ser copiado nem movido, e destruir um mutex detido causa comportamento indefinido.

No exemplo, duas threads incrementam counter sob o mesmo bloqueio. Cada chamada a join() espera apenas que termine a thread representada pelo objeto sobre o qual é feita a chamada. Antes de ler o contador, o exemplo espera por cada thread em separado com first.join() e second.join(), pelo que o resultado é 2000, independentemente da ordem de execução. O exemplo utiliza funcionalidades disponíveis em C++23; a norma de compilação indicada não atesta um ambiente de execução de produção. A fonte referenciada é um projeto de norma em evolução, não uma edição fixa de C++23.

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