0Pricing
C++ Academy · Aula

std::mutex, lock_guard e unique_lock

Proteja o estado partilhado com mutexes e auxiliares de bloqueio baseados em RAII

std::mutex, lock_guard e unique_lock é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

Por que usar um mutex?

Várias linhas de execução que acessam os mesmos dados competem por eles. Um mutex garante exclusão mútua: somente uma linha de execução mantém o bloqueio por vez.

Noções básicas de std::mutex

Construa, bloqueie e desbloqueie. O bloqueio manual é propenso a erros — sempre use auxiliares RAII.

#include <mutex>
std::mutex mtx;

mtx.lock();
// critical section
mtx.unlock();

std::lock_guard: bloqueio RAII

O bloqueio RAII mais simples. Bloqueia no construtor e desbloqueia no destrutor. Funciona perfeitamente para seções críticas que não lançam exceções.

std::mutex mtx;
int counter = 0;

void increment() {
    std::lock_guard<std::mutex> lock(mtx);
    ++counter;
}

std::scoped_lock (C++17)

Como lock_guard, mas pode bloquear vários mutexes de uma só vez sem causar um impasse. Prefira-o no código moderno.

#include <mutex>
std::scoped_lock lock(mtx1, mtx2, mtx3);  // locks all atomically

std::unique_lock: bloqueio flexível

Tem mais recursos que lock_guard:

  • Pode ser desbloqueado e bloqueado novamente no meio do escopo
  • Pode ser movido (transferência de propriedade)
  • É usado com variáveis de condição
std::unique_lock<std::mutex> lock(mtx);
lock.unlock();        // release temporarily
// ... do something without the lock ...
lock.lock();           // reacquire

Evitando impasses

Duas linhas de execução podem entrar em um impasse se adquirirem bloqueios em ordens diferentes. Adquira-os em uma ordem global consistente ou use std::scoped_lock com vários mutexes.

std::lock para vários mutexes

Antes do C++17, use std::lock para adquirir vários mutexes atomicamente. O std::scoped_lock do C++17 é mais simples.

Mutex recursivo

std::recursive_mutex permite que uma linha de execução o bloqueie várias vezes. Isso geralmente indica problemas de design — refatore em vez disso.

try_lock e timed_mutex

try_lock retorna imediatamente se o bloqueio estiver ocupado. std::timed_mutex permite tentativas de bloqueio com limite de tempo.

Bloqueio para leitores e escritores

std::shared_mutex (C++17) permite vários leitores simultâneos ou um único escritor exclusivo. Use-o para cargas de trabalho predominantemente de leitura.

std::shared_mutex sm;
void read()  { std::shared_lock lk(sm);   /* read */ }
void write() { std::unique_lock lk(sm);   /* write */ }

Compromisso de granularidade

Bloquear de forma muito ampla prejudica a concorrência. Bloquear de forma muito granular adiciona sobrecarga. Analise o desempenho e ajuste.

Alternativas sem bloqueios

Em cenários de alta contenção, considere estruturas de dados sem bloqueios (atômicas, filas sem bloqueios). É muito mais difícil escrevê-las corretamente — use-as somente quando necessário e após verificar seu funcionamento.

Verificação rápida

Qual bloqueio RAII você deve preferir ao bloquear vários mutexes de uma só vez?

Resumo

Use std::lock_guard para seções críticas simples, std::scoped_lock para vários mutexes e std::unique_lock quando precisar de flexibilidade (variáveis de condição, desbloqueio manual). Sempre use RAII — nunca chame lock/unlock manualmente.

Perguntas Frequentes

A aula “std::mutex, lock_guard e unique_lock” é grátis?

Sim — o texto completo de “std::mutex, lock_guard e unique_lock” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “std::mutex, lock_guard e unique_lock”?

Proteja o estado partilhado com mutexes e auxiliares de bloqueio baseados em RAII Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “std::mutex, lock_guard e unique_lock”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. std::thread: juntar e separar
  2. std::mutex, lock_guard e unique_lock
  3. Variáveis de condição e padrões de trabalhadores
  4. Noções básicas de std::async e std::future
← Voltar para C++ Academy