CS Fundamentals Trainer · Guias
Concorrência: condições de corrida, deadlocks e o event loop
Threads, event loops e goroutines comparados; a atualização perdida e o deadlock como animações que você pode percorrer; o que as correções custam, medido em Go e Python; e a única regra de um event loop.
29 min de leitura
Concorrência é ter várias coisas em andamento ao mesmo tempo: um servidor tratando mil requisições, um programa esperando por um banco de dados enquanto também lê um arquivo, uma interface que continua responsiva enquanto baixa algo. É também a fonte dos bugs que as pessoas acham mais difíceis de reproduzir, porque o programa está correto na maioria das execuções e errado em algumas. Este guia constrói o vocabulário (threads, event loops, goroutines), mostra as duas falhas clássicas (a condição de corrida e o deadlock) com animações que você pode percorrer, mede as correções e termina com as perguntas que os entrevistadores fazem.
Os números abaixo vêm de pequenos programas executados uma vez para este guia, em um contêiner Linux de 2 núcleos com Go 1.24, Python 3.13 e Node 22. São ilustrações de um comportamento, não benchmarks: tempos e contagens mudam de execução para execução e de máquina para máquina, e uma proporção medida aqui não se transfere para a sua carga de trabalho. O código de cada experimento está no apêndice para que você possa executá-lo.
1. Concorrência, paralelismo e três modelos
Concorrência é estruturar um programa como várias tarefas que progridem em tempos sobrepostos. Paralelismo é executar várias tarefas no mesmo instante em núcleos de CPU diferentes. Você pode ter concorrência sem paralelismo (um núcleo alternando entre tarefas), e o paralelismo só é útil se o trabalho puder ser dividido.
Diagram: Three common ways to run many tasks at once
| Threads | Event loop | Goroutines (Go) | Atores (Erlang, Akka) | |
|---|---|---|---|---|
| Roda em | threads do SO, escalonadas pelo SO | uma thread | muitas tarefas leves multiplexadas em poucas threads do SO pelo runtime do Go | muitos processos leves, escalonados pelo runtime |
| Memória compartilhada | sim, por padrão | sim, mas um callback roda por vez | sim, a menos que você evite: os canais são a forma idiomática de passar dados, mas nada impede duas goroutines de tocar uma variável | não: cada ator é dono do seu estado e os outros só podem lhe enviar mensagens |
| Usa vários núcleos | sim (não no CPython, veja a seção 2) | não, a menos que você adicione workers ou processos | sim | sim |
| Bug clássico | data races, deadlock | bloquear o loop, condições de corrida lógicas entre awaits | data races em variáveis compartilhadas, deadlock em canais e locks, goroutines vazadas | uma caixa de correio cheia, ordem das mensagens, deadlock por ciclos de requisições |
| Exemplos | Java, C# Thread, Python threading | Node.js, Python asyncio, navegadores | Go | Erlang/Elixir, Akka |
O modelo de atores é uma forma de organizar estado e comunicação: o estado é privado de um ator e todo o resto acontece por mensagens. As goroutines do Go são um tipo mais leve de tarefa que pode ser usado nesse estilo (o provérbio do Go é "não se comunique compartilhando memória; compartilhe memória comunicando-se"), mas um programa Go também pode compartilhar memória e, nesse caso, precisa sincronizá-la como qualquer programa com threads.
O async/await do C# não é a mesma coisa que um event loop de thread única. Depois de um await, o resto do método pode continuar em uma thread do pool, em paralelo com outro código, a menos que o chamador rode em um contexto que o traga de volta a uma thread (uma thread de interface, o ASP.NET clássico). Então um código C# que compartilha dados entre tarefas pode ter data races reais e precisa das ferramentas da seção 3. Note que um lock não pode conter um await; use SemaphoreSlim (await gate.WaitAsync()) para proteger uma seção crítica assíncrona.
Uma tarefa é I/O-bound quando passa a maior parte do tempo esperando (rede, disco, banco de dados) e CPU-bound quando passa a maior parte calculando. Esperar não custa nada se o modelo pode rodar outra coisa nesse meio-tempo, e é por isso que um único processo Node.js pode atender milhares de conexões. Calcular precisa de núcleos, e é por isso que um handler Node.js CPU-bound precisa de uma worker thread ou de um processo separado (seção 5).
2. Condições de corrida: a atualização perdida
Dois termos são muitas vezes usados como se fossem um só:
- Um data race é uma falha de baixo nível: duas threads acessam a mesma memória ao mesmo tempo sem sincronização e pelo menos uma delas escreve. As linguagens definem o que tal programa pode fazer (o modelo de memória do Go e o C++ o tratam como um bug; o Java dá garantias fracas). Os detectores de corrida procuram por isso.
- Uma condição de corrida (race condition) é qualquer bug em que o resultado depende da ordem ou do momento dos eventos. Ela pode existir sem nenhum data race: cada acesso individual à memória pode estar devidamente travado, e o programa ainda estar errado porque a sequência de passos não é protegida como um todo (uma verificação e uma atualização posterior entre as quais outro código pode se enfiar). O exemplo em JavaScript abaixo é desse tipo.
Corrigir um não corrige o outro. Um lock em torno de cada variável remove o data race, mas não necessariamente a condição de corrida; proteger a invariante (seção 3) resolve ambos.
A forma clássica de uma corrida é a atualização perdida (lost update). counter += 1 parece um passo só, mas a máquina faz três: ler o valor, somar um e escrevê-lo de volta. Se duas threads intercalam esses passos, as duas leem o mesmo valor antigo e um dos incrementos desaparece.
Percorra abaixo. Sem o lock, as duas threads leem 0, as duas calculam 1 e o contador termina em 1. Marque a caixa para proteger a atualização com um lock e execute de novo.
Interactive simulation: lost update
O mesmo bug em código real. Quatro tarefas somam um, cada uma, um milhão de vezes; a resposta deveria ser 4 000 000.
counter := 0
var wg sync.WaitGroup
for w := 0; w < 4; w++ {
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < 1_000_000; i++ {
counter++ // read, add, write: not one step
}
}()
}
wg.Wait()
fmt.Println(counter)
int counter = 0;
var tasks = Enumerable.Range(0, 4).Select(_ => Task.Run(() =>
{
for (int i = 0; i < 1_000_000; i++)
counter++; // read, add, write: not one step
}));
await Task.WhenAll(tasks);
Console.WriteLine(counter);
Executado três vezes em Go, o contador terminou em 2 800 244, 2 252 535 e 2 278 252 em vez de 4 000 000. Isso é de 30 a 44 por cento dos incrementos perdidos, e diferente a cada vez. O Go pode apontar o bug para você: compile ou execute com -race (go run -race .) e o detector de corrida imprime WARNING: DATA RACE com os dois acessos conflitantes e as goroutines que os fizeram. Use-o em testes e na CI.
O bug se esconde no Python (e depois não)
No CPython, o global interpreter lock (GIL) deixa apenas uma thread rodar bytecode Python por vez. Quatro threads, cada uma executando counter += 1 um milhão de vezes, não perderam nada em três execuções (4 000 000 todas as vezes). Isso não torna o código correto: o interpretador pode trocar de thread entre bytecodes, e um build free-threaded sem o GIL está disponível como opção experimental desde o Python 3.13 (PEP 703). Qualquer pausa entre a leitura e a escrita expõe o problema de imediato:
def read_modify_write():
global counter
for _ in range(N):
value = counter # read
time.sleep(0) # any call that lets another thread run
counter = value + 1 # write back
Com 4 threads e N = 200 000 (800 000 esperados), a versão sem proteção terminou em 200 004, 200 000 e 200 000, perdendo cerca de três quartos das atualizações: toda thread leu o mesmo valor em cada rodada e todas as escritas menos uma foram sobrescritas. Com with lock: em torno das três linhas, a resposta foi exatamente 800 000. A lição: um teste que passa não prova que uma corrida está ausente.
Check-then-act, sem nenhuma thread
As condições de corrida não são só um problema de threads. O JavaScript de thread única também tem uma, porque cada await é um ponto em que outro código roda. Não há data race aqui (só um callback toca balance em cada instante), mas a invariante "o saldo nunca fica abaixo de zero" é quebrada:
let balance = 100;
async function withdraw(amount) {
if (balance >= amount) { // check
await audit(amount); // other callbacks run here
balance -= amount; // act on information that is now stale
}
}
await Promise.all([withdraw(80), withdraw(80)]);
console.log(balance); // -60
As duas chamadas passaram na verificação enquanto o saldo ainda era 100. Isso se chama check-then-act (ou time-of-check to time-of-use), e a mesma forma aparece em bancos de dados ("select e depois update") e em sistemas de arquivos ("existe? então crie"). A seção 3 mostra as correções.
3. Corrigindo corridas: quatro ferramentas
- Exclusão mútua (um lock, mutex). Só uma tarefa pode estar dentro da seção crítica por vez. Simples e geral, mas faz as tarefas esperarem e é a causa dos deadlocks (seção 4).
- Operações atômicas. O hardware executa o ler-modificar-escrever como um passo indivisível. Rápido, mas limitado a valores simples como contadores e flags.
- Passagem de mensagens e posse. Não compartilhe os dados. Uma tarefa é dona deles e as outras lhe enviam requisições (um canal, uma fila, a caixa de correio de um ator). O ditado do Go é "não se comunique compartilhando memória; compartilhe memória comunicando-se".
- Imutabilidade. Dados que nunca mudam não sofrem corrida. Compartilhe-os livremente e construa uma nova cópia para mudar.
lock = threading.Lock()
def bump():
global counter
for _ in range(N):
with lock: # critical section
counter += 1
var mu sync.Mutex
mu.Lock()
counter++
mu.Unlock()
// or, for a counter, one atomic instruction:
var n atomic.Int64
n.Add(1)
private static readonly object Gate = new();
lock (Gate)
{
counter++;
}
// or, for a counter, one atomic instruction:
Interlocked.Increment(ref counter);
Para o check-then-act do JavaScript, faça o passo inteiro de verificar e agir rodar um chamador por vez. Uma cadeia de promises funciona como um minúsculo lock: com ela, as duas retiradas acima terminam em 20 (a segunda é recusada), não em -60.
let tail = Promise.resolve();
function exclusive(fn) {
const run = tail.then(fn);
tail = run.catch(() => {}); // a failure must not block the next caller
return run;
}
await Promise.all([80, 80].map((a) => exclusive(() => withdraw(a))));
O que as correções custam (uma execução ilustrativa)
O mesmo programa Go de quatro goroutines e 4 000 000 de incrementos, tornado correto de três formas. Esta é uma única execução de um micro-benchmark em um contêiner de 2 núcleos, então leia-a como um retrato da forma da troca. O programa completo está no apêndice.
| Abordagem | Resultado | Tempo (uma execução) |
|---|---|---|
| Sem proteção | 2,3 a 2,8 milhões (errado) | 3 ms |
sync.Mutex | 4 000 000 | 230 ms |
atomic.Int64 | 4 000 000 | 60 ms |
| Uma goroutine é dona do contador, as outras lhe enviam mensagens por um canal com buffer | 4 000 000 | 296 ms |
A resposta errada é a mais rápida porque ninguém espera. Nesta execução o atômico levou cerca de um quarto do tempo do mutex, e a versão com canal foi a mais lenta por incremento. Não transforme isso em uma regra como "atômicos são quatro vezes mais rápidos que mutexes". A diferença depende de quantas tarefas disputam a mesma variável (contenção), da CPU e do comportamento do seu cache, do runtime da linguagem e da implementação de lock dele e, acima de tudo, de quanto trabalho acontece dentro da seção protegida: quando a seção faz trabalho de verdade, o custo do lock em si é uma parte pequena e a vantagem do atômico desaparece. Um atômico também não consegue proteger uma invariante que abrange vários campos, o que um mutex ou um único dono consegue. Um canal custa mais por operação, mas move a posse, de modo que uma goroutine pode ser dona de uma estrutura de dados inteira sem nenhum lock.
No Python o lock também deixou o laço de quatro threads mais lento, por um fator que variou entre cerca de 2 e 4 em execuções repetidas, mas essa comparação pertence ao CPython com o seu GIL e diz pouco sobre outros runtimes.
Meça a sua própria carga de trabalho, com a contenção real e o trabalho real na seção crítica, antes de escolher uma ferramenta por velocidade.
Regras práticas:
- Mantenha as seções críticas pequenas e nunca faça trabalho lento (uma chamada de rede, uma leitura de disco) enquanto segura um lock.
- Proteja a invariante, não a variável. Se dois campos precisam mudar juntos (debitar uma conta, creditar outra), um lock precisa cobrir as duas mudanças.
- Prefira a ferramenta de mais alto nível que sirva: um contador quer um atômico, um cache compartilhado quer um mapa concorrente ou um mutex, um pipeline de estágios quer canais ou filas. Escolha primeiro por correção e clareza, e otimize apenas onde uma medição mostrar que um lock é o gargalo.
- Em um banco de dados a mesma ideia é uma transação com o nível de isolamento certo ou um lock de linha (veja níveis de isolamento de transação).
4. Deadlock
Um deadlock é quando duas ou mais tarefas esperam, cada uma, por algo que a outra segura, de modo que nenhuma pode continuar. O caso de livro-texto precisa de dois locks. A thread 1 pega A e depois quer B. A thread 2 pega B e depois quer A. Se cada uma pega o seu primeiro lock antes de a outra pegar o segundo, as duas esperam para sempre.
Percorra, depois marque a caixa para fazer as duas threads pegarem os locks na mesma ordem.
Interactive simulation: deadlock
Um deadlock precisa destas quatro condições (Coffman, 1971) ao mesmo tempo. Remova qualquer uma e ele não pode acontecer:
| Condição | Significado | O que a impede (prevenção) |
|---|---|---|
| Exclusão mútua | um recurso é usado por uma tarefa por vez | use dados imutáveis, somente leitura ou lock-free, ou dê a cada tarefa a sua própria cópia |
| Hold and wait | uma tarefa segura um recurso enquanto espera outro | adquira tudo de uma vez, ou segure no máximo um lock por vez |
| Sem preempção | um recurso não pode ser tomado do seu detentor | raro para locks comuns; alguns sistemas podem forçar isso (um banco de dados aborta uma transação e libera seus locks) |
| Espera circular | A espera por B, B espera por A | dê a todos os locks uma ordem global e sempre os pegue nessa ordem |
Há três estratégias diferentes, e ajuda não misturá-las:
- A prevenção projeta o sistema de modo que uma condição nunca possa valer. A ordenação de locks é o exemplo prático: se toda thread pega A antes de B, ninguém pode esperar em círculo. A regra mais barata: decida uma ordem, documente-a e, onde a ordem natural não é óbvia (transferir dinheiro entre duas contas), ordene por algo estável como o id da conta. Segure também o menor número possível de locks de uma vez e nunca chame código desconhecido (um callback, um método sobrescrevível) enquanto segura um lock.
- A evitação (avoidance) decide em tempo de execução se conceder um pedido poderia levar a um deadlock e o adia, se for o caso (o algoritmo do banqueiro). Ela precisa saber de antemão as necessidades máximas de cada tarefa, então é sobretudo uma ideia de livro-texto e rara em código de aplicação.
- A detecção e recuperação aceita que um deadlock pode acontecer e o desfaz depois. Um timeout ao adquirir um lock (
tryLock,SemaphoreSlim.Wait(timeout), um prazo decontext) não tira o lock do seu detentor; ele deixa a tarefa que espera desistir, liberar o que segura e tentar de novo ou falhar. Isso transforma um travamento permanente em uma espera limitada, mas não remove a causa: pode esconder um bug de projeto, pode disparar indevidamente quando o detentor está apenas lento, e tarefas que recuam e repetem em sincronia podem sofrer livelock (acrescente jitter aleatório). Um banco de dados faz a recuperação por você: o PostgreSQL percebe um ciclo de locks depois dedeadlock_timeout(um segundo por padrão), aborta uma das transações comERROR: deadlock detected, e espera-se que a aplicação a repita.
Use a prevenção onde puder, e a recuperação (timeouts, cancelamento, rollback e retry) como rede de segurança, não como o projeto.
O Go detecta o caso mais simples em tempo de execução. Quando todas as goroutines estão bloqueadas, o programa para com fatal error: all goroutines are asleep - deadlock! e um stack trace de cada uma. Isso só dispara quando todas estão travadas. Em um servidor real outras goroutines continuam rodando, então um par em deadlock simplesmente deixa de atender suas requisições em silêncio. A maioria das linguagens não dá mensagem nenhuma: um serviço em deadlock aparece como threads que nunca terminam, uma fila de requisições crescente e uso de CPU baixo. Um thread dump (jstack, dotnet-dump, py-spy dump, enviar SIGQUIT a um programa Go) lista o que cada thread está esperando e o encontra.
Um parente próximo é o livelock: as tarefas não estão bloqueadas, mas continuam reagindo umas às outras e não progridem (duas pessoas desviando uma da outra em um corredor, as duas para o mesmo lado, para sempre). O backoff aleatório resolve. A starvation (inanição) é quando uma tarefa nunca tem a sua vez porque as outras sempre ganham o lock; locks justos e filas limitadas resolvem.
5. O event loop e a única regra
Um event loop executa um callback por vez em uma thread. Quando um callback precisa esperar (uma resposta de rede, um timer), ele registra o que fazer em seguida e retorna, e o loop executa o próximo callback pronto. É por isso que o await é barato, e por isso dois callbacks de um event loop não podem tocar a mesma memória no mesmo instante: nada mais roda até você retornar ou dar await. Isso exclui data races entre callbacks, mas não condições de corrida: outro callback pode rodar em cada await, então uma verificação feita antes de um await pode estar obsoleta depois dele (o exemplo do saldo na seção 2). Worker threads com memória compartilhada (SharedArrayBuffer) e runtimes cujo código async se espalha por várias threads, como o C#, trazem de volta data races reais.
Diagram: The event loop: ready callbacks run one at a time
O preço é uma regra: nunca bloqueie o loop. Um callback que calcula por 500 ms, ou chama uma função bloqueante, segura todas as outras tarefas, inclusive as que estavam prontas muito antes.
No Node.js, um timer pedido para disparar depois de 100 ms, enquanto um laço síncrono manteve a thread ocupada por 500 ms, rodou depois de 504 ms. Os mesmos 500 ms de espera feitos com await deixaram o timer disparar a tempo, depois de 100 ms.
setTimeout(() => console.log("timer"), 100);
while (performance.now() < until) {} // blocks: the timer is late
await new Promise((r) => setTimeout(r, 500)); // yields: the timer is on time
O asyncio do Python se comporta do mesmo modo. Um ticker que deveria imprimir a cada 0,1 s foi atrasado por uma chamada time.sleep(0.5) dentro de outra corrotina: seu primeiro tick veio em 0,50 s em vez de 0,10 s. Trocá-la por await asyncio.sleep(0.5) deu ticks em 0,10, 0,20 e 0,30 s, como esperado.
async def blocking():
time.sleep(0.5) # freezes every task on the loop
async def friendly():
await asyncio.sleep(0.5) # the loop runs other tasks meanwhile
Coisas que bloqueiam o loop em silêncio: um laço intensivo de CPU ou um parse grande de JSON, um driver síncrono de arquivo ou banco de dados, requests.get dentro de um async def, uma expressão regular com backtracking catastrófico. As correções são usar a versão assíncrona da biblioteca ou tirar o trabalho do loop: uma worker thread (worker_threads, asyncio.to_thread, Task.Run) para chamadas bloqueantes, um processo separado para computação pesada.
Uma armadilha parente no C# é o async-over-sync: chamar .Result ou .Wait() em uma task a partir de código que roda em um contexto que permite apenas um pedaço de código por vez (o ASP.NET clássico ou uma thread de interface). A thread bloqueada espera pela task, e a task precisa dessa mesma thread para terminar. É um deadlock com um único lock. A correção é usar await por toda a cadeia de chamadas.
6. Escolhendo um modelo
| Carga de trabalho | Bom encaixe | Por quê |
|---|---|---|
| Muitas conexões, a maioria esperando (servidor web, chat, API gateway) | event loop ou goroutines | esperar é barato; milhares de tarefas, poucas threads |
| Computação pesada (processamento de imagem, parsing, codificação) | processos ou threads em vários núcleos | precisa de núcleos; no CPython use multiprocessing ou um build free-threaded, por causa do GIL |
| Bibliotecas bloqueantes que você não pode mudar | pool de threads | mantém o bloqueio fora do event loop |
| Pipelines de estágios | canais ou filas | os dados se movem, nada é compartilhado |
As tarefas não custam o mesmo. No Go, 100 000 goroutines estacionadas ocuparam cerca de 2,0 KiB de pilha cada uma e foram criadas em menos de 400 ms, então criar uma por requisição é normal. As threads do SO são mais pesadas: cada uma reserva a sua própria pilha (muitas vezes 8 MiB de espaço de endereços por padrão no Linux), e o escalonador precisa alternar entre elas. Iniciar 2 000 threads Python levou 0,17 s aqui, e um servidor com dezenas de milhares de threads gasta o tempo trocando em vez de trabalhando. É por isso que os servidores de thread por requisição usam um pool limitado e por isso existem os event loops e as goroutines.
Dimensione um pool de propósito, mas trate qualquer fórmula como uma estimativa inicial. Para trabalho CPU-bound, um primeiro palpite é cerca de um worker por núcleo; mais só acrescenta trocas. Para trabalho que passa tempo esperando, uma estimativa aproximada é núcleos * (1 + tempo de espera / tempo de computação). Ela supõe carga estável, esperas que não dependem umas das outras e nenhum limite a jusante. Os sistemas reais quebram essas suposições: rajadas fazem as filas crescer, o trabalho varia de tamanho, um banco de dados ou uma API que você chama pode permitir apenas um número fixo de conexões (o que então limita o tamanho útil do pool, seja qual for a fórmula) e o runtime pode se comportar de outro modo (o GIL, um event loop). Então comece pela estimativa, depois faça testes de carga e observe o tamanho da fila e os percentis de latência, e defina o limite em relação à capacidade do que o pool chama.
7. Outras coisas que dão errado
- Concorrência sem limite. Iniciar uma tarefa para cada item de uma lista grande abre milhares de conexões de uma vez e sobrecarrega o banco de dados ou a API remota. Limite com um semáforo, um pool de workers ou uma fila limitada, para que consumidores lentos desacelerem os produtores (backpressure).
- Esgotamento do pool de threads. Se toda thread do pool bloqueia esperando por uma tarefa que está na fila atrás delas no mesmo pool, nada termina. Parece um deadlock sem nenhum lock.
- Visibilidade e ordenação. Sem sincronização, a escrita de uma thread pode não ser vista por outra de forma alguma, ou ser vista fora de ordem, por causa dos caches da CPU e da reordenação do compilador. Locks, atômicos e canais também atuam como barreiras de memória que tornam as escritas visíveis. O modelo de memória do Go é um relato legível das regras; o conselho dele para programas com corridas é "não seja esperto".
- Vazamentos e cancelamento. Uma tarefa que ninguém espera continua rodando (e segurando memória e conexões) depois que o chamador desistiu. Passe um sinal de cancelamento (
context.Contextno Go,CancellationTokenno C#,AbortControllerno JavaScript) e saiba sempre quem é responsável por parar cada tarefa. - Erros perdidos. Uma exceção em uma tarefa em segundo plano não vai a lugar nenhum a menos que alguém dê await ou join nela. Colete os resultados com
Promise.all,Task.WhenAll,errgroupou equivalente. - Retries multiplicam a carga. Um retry concorrente a cada falha transforma uma dependência lenta em uma tempestade de retries (veja o guia do rate limiter e estratégias de cache para stampedes).
8. Erros comuns
- Supor que
counter += 1,x = x + 1ouif (not exists) createé atômico. - Confiar em um teste que passou: uma corrida pode precisar de milhares de execuções, ou de outra CPU, para aparecer.
- Travar a variável em vez da invariante, de modo que duas atualizações relacionadas ainda se intercalam.
- Segurar um lock durante I/O lento ou ao chamar código que você não controla.
- Pegar vários locks sem uma ordem global.
- Bloquear o event loop com trabalho de CPU ou uma biblioteca síncrona.
- Misturar síncrono e assíncrono:
.Resulte.Wait()no C#,asyncio.rundentro de um loop em execução,time.sleepem uma corrotina. - Iniciar tarefas ilimitadas, ou tarefas que ninguém espera ou cancela.
- "Consertar" uma corrida com
sleep: isso apenas move o momento.
9. Coisas a mencionar em uma entrevista
- Defina as palavras: concorrência versus paralelismo, I/O-bound versus CPU-bound.
- Explique uma corrida com os três passos (ler, modificar, escrever) e dê a atualização perdida ou o check-then-act como exemplo.
- Conheça o cardápio de correções: lock, atômico, passagem de mensagens, imutabilidade, e a troca de cada um.
- Nomeie as quatro condições do deadlock e separe prevenção (ordenação de locks), evitação e recuperação (timeouts, rollback e retry, thread dumps).
- Explique o event loop e a regra de nunca bloqueá-lo; diga para onde vai o trabalho de CPU.
- Explique o GIL com honestidade: ele torna algumas corridas mais raras, mas não as remove, e não impede que o
multiprocessingou a espera por I/O sejam concorrentes. - Diga como você encontraria um bug: um detector de corrida (
go -race, ThreadSanitizer), testes de estresse que repetem muitas vezes com muitas threads, thread dumps para travamentos.
Perguntas que os entrevistadores gostam de acrescentar:
- "Por que um mutex deixa um programa mais lento, e quando isso é aceitável?" As tarefas esperam umas pelas outras; aceitável quando a seção crítica é curta e a contenção é baixa.
- "Uma flag
volatileou atômica basta para proteger uma estrutura de dados?" Não. Ela protege um valor; atualizações em vários passos precisam de um lock ou de um único dono. - "Uma thread só, então sem corridas?" Só se nenhum
awaitou callback puder rodar entre o seu check e o seu act. Veja a seção 2. - "Quantas threads um pool deveria ter?" Cerca do número de núcleos para trabalho CPU-bound, mais para trabalho que espera; meça.
- "Seu serviço travou e a CPU está ociosa. O que você faz?" Tire thread dumps, procure threads esperando umas pelas outras, confira os tamanhos de pool e os timeouts a jusante.
Resumo rápido
- Concorrência é ter tarefas sobrepostas; paralelismo é executá-las em vários núcleos.
- Threads compartilham memória, event loops executam um callback por vez, goroutines podem compartilhar memória ou passar mensagens por canais, e atores só passam mensagens.
- Um data race é acesso não sincronizado à memória compartilhada; uma condição de corrida é qualquer bug dependente de tempo, e pode existir sem um data race.
counter += 1é ler, somar, escrever, e dois deles podem perder uma atualização (de 30 a 44 por cento perdidos no experimento em Go). - Um teste que passa prova pouco: o GIL do Python escondeu a atualização perdida em 12 milhões de incrementos e um único
sleep(0)a expôs de imediato. - Corrija corridas com um lock, um atômico, um único dono com mensagens ou dados imutáveis, e mantenha as seções críticas pequenas.
- Um deadlock precisa de exclusão mútua, hold and wait, ausência de preempção e espera circular; uma ordem global de locks previne o círculo, e timeouts ou rollback recuperam quando ele acontece mesmo assim.
- Nunca bloqueie um event loop: um laço ocupado de 500 ms fez um timer de 100 ms disparar em 504 ms.
- Limite a concorrência, passe o cancelamento e olhe os resultados das tarefas em segundo plano.
Apêndice: o código dos experimentos
Cada número acima veio de um destes programas. Execute-os você mesmo; espere números diferentes em outra máquina, e números diferentes a cada execução.
Go: atualização perdida, mutex, atômico e canal
Execute com go run . (contagens e tempos) e go run -race . (o relatório do detector de corrida). Salve como main.go em uma pasta com um go.mod (go mod init race).
package main
import (
"fmt"
"sync"
"sync/atomic"
"time"
)
const (
workers = 4
perWork = 1_000_000
)
func run(name string, work func(wg *sync.WaitGroup)) {
var wg sync.WaitGroup
start := time.Now()
for i := 0; i < workers; i++ {
wg.Add(1)
go work(&wg)
}
wg.Wait()
fmt.Printf("%-8s took %v\n", name, time.Since(start).Round(time.Millisecond))
}
func main() {
want := workers * perWork
for trial := 0; trial < 3; trial++ {
plain := 0
run("plain", func(wg *sync.WaitGroup) {
defer wg.Done()
for i := 0; i < perWork; i++ {
plain++
}
})
fmt.Printf(" expected %d got %d lost %d\n", want, plain, want-plain)
}
var mu sync.Mutex
locked := 0
run("mutex", func(wg *sync.WaitGroup) {
defer wg.Done()
for i := 0; i < perWork; i++ {
mu.Lock()
locked++
mu.Unlock()
}
})
fmt.Printf(" expected %d got %d\n", want, locked)
var atom atomic.Int64
run("atomic", func(wg *sync.WaitGroup) {
defer wg.Done()
for i := 0; i < perWork; i++ {
atom.Add(1)
}
})
fmt.Printf(" expected %d got %d\n", want, atom.Load())
// one goroutine owns the counter; the others send it messages
ch := make(chan struct{}, 1024)
done := make(chan int)
go func() {
n := 0
for range ch {
n++
}
done <- n
}()
run("channel", func(wg *sync.WaitGroup) {
defer wg.Done()
for i := 0; i < perWork; i++ {
ch <- struct{}{}
}
})
close(ch)
fmt.Printf(" expected %d got %d\n", want, <-done)
}
Python: o GIL e a atualização perdida
Execute python3 race.py. A primeira parte é o laço simples counter += 1; defina explicit como True para usar a versão de ler, pausar, escrever (é lenta: cerca de um minuto com o lock, então diminua N se estiver impaciente).
import sys, threading, time
explicit = False
N = 200_000 if explicit else 1_000_000
counter = 0
lock = threading.Lock()
def bump(use_lock):
global counter
for _ in range(N):
if use_lock:
lock.acquire()
if explicit:
value = counter # read
time.sleep(0) # lets another thread run
counter = value + 1 # write back
else:
counter += 1
if use_lock:
lock.release()
def run(use_lock, threads=4):
global counter
counter = 0
ts = [threading.Thread(target=bump, args=(use_lock,)) for _ in range(threads)]
start = time.perf_counter()
for t in ts: t.start()
for t in ts: t.join()
return counter, time.perf_counter() - start
print(sys.version.split()[0], "GIL enabled:", getattr(sys, "_is_gil_enabled", lambda: True)())
for use_lock in (False, True):
for _ in range(3):
got, secs = run(use_lock)
print(f"lock={use_lock} expected {4 * N:,} got {got:,} in {secs:.2f}s")
JavaScript: uma corrida de check-then-act e um event loop bloqueado
Execute cada arquivo com node (Node 22 ou posterior; os arquivos são módulos ES, então nomeie-os .mjs).
// race.mjs
const audit = () => new Promise((resolve) => setTimeout(resolve, 10));
let balance = 100;
async function withdraw(amount) {
if (balance >= amount) {
await audit();
balance -= amount;
}
}
await Promise.all([withdraw(80), withdraw(80)]);
console.log("unprotected:", balance); // -60
E o event loop bloqueado:
// blocked.mjs: a timer asked for 100 ms behind 500 ms of busy work
const start = performance.now();
setTimeout(() => console.log(`timer ran after ${Math.round(performance.now() - start)} ms`), 100);
const until = performance.now() + 500;
while (performance.now() < until) { /* busy */ }
console.log(`busy loop finished at ${Math.round(performance.now() - start)} ms`);
// replace the busy loop with: await new Promise((r) => setTimeout(r, 500));
// and the timer runs after about 100 ms
Python asyncio: bloqueando o loop
import asyncio, time
async def ticker(start):
for _ in range(3):
await asyncio.sleep(0.1)
print(f" tick at {time.perf_counter() - start:.2f}s")
async def blocking(start):
time.sleep(0.5) # blocks the whole event loop
async def friendly(start):
await asyncio.sleep(0.5) # yields while waiting
async def main(work):
start = time.perf_counter()
await asyncio.gather(ticker(start), work(start))
asyncio.run(main(blocking))
asyncio.run(main(friendly))
Go: o custo de uma goroutine estacionada
package main
import (
"fmt"
"runtime"
"sync"
"time"
)
func main() {
const n = 100_000
var before, after runtime.MemStats
runtime.GC()
runtime.ReadMemStats(&before)
start := time.Now()
stop := make(chan struct{})
var wg sync.WaitGroup
for i := 0; i < n; i++ {
wg.Add(1)
go func() { defer wg.Done(); <-stop }()
}
time.Sleep(200 * time.Millisecond)
runtime.ReadMemStats(&after)
fmt.Printf("%d goroutines parked: %.1f KiB each (stacks), created in under %v\n",
n, float64(after.StackInuse-before.StackInuse)/1024/n, time.Since(start).Round(10*time.Millisecond))
close(stop)
wg.Wait()
}
Fontes
- O Projeto Go, The Go Memory Model. Quando uma escrita de uma goroutine é garantidamente vista por outra, e por que programas com corridas não são seguros.
- Documentação do Go, Data Race Detector. A flag
-raceusada na seção 2. - Documentação do Python, threading e asyncio.
- Sam Gross, PEP 703: Making the Global Interpreter Lock Optional in CPython.
- Documentação do Node.js, The Node.js Event Loop.
- E. G. Coffman, M. J. Elphick e A. Shoshani, "System Deadlocks", ACM Computing Surveys 3(2), 1971. As quatro condições da seção 4.
- Microsoft, Managed threading best practices. Locks,
Interlockede orientações sobre deadlock para .NET.
Pratique este tema: CS Fundamentals