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

ThreadsEvent loopGoroutines (Go)Atores (Erlang, Akka)
Roda emthreads do SO, escalonadas pelo SOuma threadmuitas tarefas leves multiplexadas em poucas threads do SO pelo runtime do Gomuitos processos leves, escalonados pelo runtime
Memória compartilhadasim, por padrãosim, mas um callback roda por vezsim, 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ávelnão: cada ator é dono do seu estado e os outros só podem lhe enviar mensagens
Usa vários núcleossim (não no CPython, veja a seção 2)não, a menos que você adicione workers ou processossimsim
Bug clássicodata races, deadlockbloquear o loop, condições de corrida lógicas entre awaitsdata races em variáveis compartilhadas, deadlock em canais e locks, goroutines vazadasuma caixa de correio cheia, ordem das mensagens, deadlock por ciclos de requisições
ExemplosJava, C# Thread, Python threadingNode.js, Python asyncio, navegadoresGoErlang/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ó:

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

  1. 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).
  2. 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.
  3. 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".
  4. 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.

AbordagemResultadoTempo (uma execução)
Sem proteção2,3 a 2,8 milhões (errado)3 ms
sync.Mutex4 000 000230 ms
atomic.Int644 000 00060 ms
Uma goroutine é dona do contador, as outras lhe enviam mensagens por um canal com buffer4 000 000296 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:

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çãoSignificadoO que a impede (prevenção)
Exclusão mútuaum recurso é usado por uma tarefa por vezuse dados imutáveis, somente leitura ou lock-free, ou dê a cada tarefa a sua própria cópia
Hold and waituma tarefa segura um recurso enquanto espera outroadquira tudo de uma vez, ou segure no máximo um lock por vez
Sem preempçãoum recurso não pode ser tomado do seu detentorraro para locks comuns; alguns sistemas podem forçar isso (um banco de dados aborta uma transação e libera seus locks)
Espera circularA espera por B, B espera por Adê 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:

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 trabalhoBom encaixePor quê
Muitas conexões, a maioria esperando (servidor web, chat, API gateway)event loop ou goroutinesesperar é barato; milhares de tarefas, poucas threads
Computação pesada (processamento de imagem, parsing, codificação)processos ou threads em vários núcleosprecisa de núcleos; no CPython use multiprocessing ou um build free-threaded, por causa do GIL
Bibliotecas bloqueantes que você não pode mudarpool de threadsmantém o bloqueio fora do event loop
Pipelines de estágioscanais ou filasos 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

8. Erros comuns

  1. Supor que counter += 1, x = x + 1 ou if (not exists) create é atômico.
  2. Confiar em um teste que passou: uma corrida pode precisar de milhares de execuções, ou de outra CPU, para aparecer.
  3. Travar a variável em vez da invariante, de modo que duas atualizações relacionadas ainda se intercalam.
  4. Segurar um lock durante I/O lento ou ao chamar código que você não controla.
  5. Pegar vários locks sem uma ordem global.
  6. Bloquear o event loop com trabalho de CPU ou uma biblioteca síncrona.
  7. Misturar síncrono e assíncrono: .Result e .Wait() no C#, asyncio.run dentro de um loop em execução, time.sleep em uma corrotina.
  8. Iniciar tarefas ilimitadas, ou tarefas que ninguém espera ou cancela.
  9. "Consertar" uma corrida com sleep: isso apenas move o momento.

9. Coisas a mencionar em uma entrevista

Perguntas que os entrevistadores gostam de acrescentar:

Resumo rápido

  1. Concorrência é ter tarefas sobrepostas; paralelismo é executá-las em vários núcleos.
  2. 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.
  3. 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).
  4. 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.
  5. 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.
  6. 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.
  7. Nunca bloqueie um event loop: um laço ocupado de 500 ms fez um timer de 100 ms disparar em 504 ms.
  8. 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

  1. 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.
  2. Documentação do Go, Data Race Detector. A flag -race usada na seção 2.
  3. Documentação do Python, threading e asyncio.
  4. Sam Gross, PEP 703: Making the Global Interpreter Lock Optional in CPython.
  5. Documentação do Node.js, The Node.js Event Loop.
  6. 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.
  7. Microsoft, Managed threading best practices. Locks, Interlocked e orientações sobre deadlock para .NET.

Pratique este tema: CS Fundamentals

Mais guias