CS Fundamentals Trainer · Guias
Runtime do Go na prática: goroutines, canais, escalonador, memória e coleta de lixo
Como o runtime do Go se comporta e quanto custa, com medições: memória e custo de início das goroutines, o escalonador G, M e P e a preempção, canais contra mutexes e atômicos, corridas de dados e o modelo de memória, vazamentos de goroutines e cancelamento com context usando um pool de workers, análise de escape e custos de alocação, GOGC e GOMEMLIMIT, e os comportamentos da linguagem que surpreendem.
40 min de leitura
O Go ficou popular em servidores porque a concorrência parece barata: você escreve go f() e uma nova goroutine roda, passa valores por canais, e o runtime distribui o trabalho pelas CPUs. Essa impressão é em grande parte verdadeira, e esconde os lugares onde o custo é real. Uma goroutine ocupa memória, um canal leva tempo, uma goroutine esquecida nunca vai embora, um ponteiro que escapa vira lixo que o coletor precisa varrer, e um laço aparentemente inocente pode prender um processador durante uma fatia de tempo inteira.
Este guia explica como o runtime do Go funciona o suficiente para prever esses custos: o que é uma goroutine e como o escalonador a executa, quanto custam canais, mutexes e operações atômicas uns em relação aos outros, como os vazamentos de goroutines acontecem e como evitá-los, como o compilador decide entre pilha e heap, como o coletor de lixo troca memória por CPU, e os comportamentos da linguagem que mais surpreendem. Quase toda afirmação vem com uma medição, e os programas estão no apêndice.
Uma nota sobre as medições. Os números marcados como "medido" vêm de programas em Go 1.24 em uma pequena VM na nuvem (2 vCPUs de um Intel Xeon a 2,1 GHz, 8 GB de memória, Linux). Os tempos variam entre execuções e entre máquinas, então leia-os pelas proporções e ordens de grandeza; onde o resultado depende de ruído, o guia dá a mediana de três execuções. Os benchmarks usam
testing.Benchmark, e a saída da análise de escape do compilador é citada dego build -gcflags='-m -l'.
1. Goroutines
Uma goroutine é uma função executando de forma concorrente, escalonada pelo runtime do Go e não pelo sistema operacional. Três propriedades a tornam barata:
- Ela começa com uma pilha pequena que cresce. O runtime começa com uma pilha de alguns quilobytes e a copia para uma maior quando ela acaba, então a goroutine paga só pelo que usa. Uma thread do sistema operacional, ao contrário, reserva uma pilha grande e fixa de espaço de endereçamento (comumente megabytes) e custa um objeto do kernel.
- Criar e trocar de goroutine acontece no espaço do usuário, sem chamada de sistema.
- Esperar é barato. Uma goroutine bloqueada em um canal, um mutex ou uma E/S de rede fica estacionada em uma fila e custa memória, mas nenhuma CPU.
Medido: goroutines foram iniciadas e estacionadas em um canal, e a memória ocupada foi lida do runtime.
| Goroutines | Tempo para iniciar todas | Por goroutine | Pilha em uso por goroutine | Memória do sistema, por goroutine |
|---|---|---|---|---|
| 1.000 | 1,7 ms | 1,7 µs | 1,98 KB | |
| 100.000 | 241 ms | 2,4 µs | 2,02 KB | 2,65 KB (271 MB no total) |
| 1.000.000 | 3,4 s | 3,4 µs | 2,20 KB | 2,56 KB (2,6 GB no total) |
Portanto, uma goroutine custa cerca de 2 KB de pilha mais algumas centenas de bytes de controle, cerca de 2,6 KB no total, e alguns microssegundos para iniciar. Um milhão delas cabe em alguns gigabytes. É por isso que o Go pode dar a cada conexão ou requisição a sua própria goroutine, e por que o velho conselho de "faça pool das suas threads" quase não se aplica.
Barato não é de graça, e não é limitado. Duas regras decorrem daí:
- Limite a concorrência do trabalho que toca algo finito: um banco de dados com 100 conexões, uma API com limite de taxa, memória por tarefa. Inicie um número fixo de workers, ou use um semáforo (um canal com buffer), em vez de uma goroutine por item de uma entrada ilimitada.
- Toda goroutine precisa de um fim. Saiba, ao escrever
go, o que a faz parar (seção 5).
2. O escalonador: G, M e P
O runtime escalona goroutines (G) em threads do sistema operacional (M), e uma thread precisa de um processador (P), um token que guarda uma fila de goroutines executáveis e a permissão de executar código Go. O número de Ps é GOMAXPROCS, que por padrão é o número de CPUs que o processo enxerga.
Diagram: Goroutines, threads and processors
O que o diagrama significa na prática:
- Uma nova goroutine vai para a fila local do P atual. Um P ocioso rouba trabalho de outro P ou pega da fila global, então a carga se espalha sem um bloqueio central.
- A E/S de rede não prende uma thread. Uma goroutine esperando um socket fica estacionada e registrada no poller de rede; quando o socket está pronto, ela volta a ser executável. Dez mil conexões ociosas são dez mil goroutines estacionadas, não dez mil threads.
- Uma goroutine em uma chamada de sistema bloqueante (uma leitura de arquivo, por exemplo) mantém a sua thread, mas o runtime entrega o P a outra thread para que as demais goroutines continuem rodando.
- Desde o Go 1.14 o escalonador pode preemptar uma goroutine que roda por tempo demais (cerca de 10 ms) mesmo que ela nunca chame uma função nem espere, usando um sinal.
Medido: 400.000 rodadas de SHA-256, divididas entre goroutines, com GOMAXPROCS diferentes em uma máquina de 2 CPUs.
| GOMAXPROCS | Goroutines dividindo o trabalho | Tempo |
|---|---|---|
| 1 | 1, 2 ou 8 | 40 ms, 42 ms, 40 ms |
| 2 | 1 | 40 ms (uma goroutine só consegue usar uma CPU) |
| 2 | 2 ou 8 | 22 ms, 21 ms (cerca de duas vezes mais rápido) |
| 4 | 2 ou 8 | 22 ms, 21 ms (sem ganho sobre 2: só existem 2 CPUs) |
Três conclusões: o paralelismo precisa tanto de várias goroutines quanto de vários Ps; mais goroutines do que CPUs não tornam o trabalho limitado por CPU mais rápido (também não custam nada a mais); e GOMAXPROCS acima do número de CPUs reais não compra nada. Em um contêiner limitado por uma cota de CPU, o runtime pode enxergar mais CPUs do que a cota permite, o que causa estrangulamento (throttling); defina GOMAXPROCS explicitamente com o limite (ou use uma biblioteca que o leia).
Concorrência não é paralelismo. Medido: com GOMAXPROCS=1, 10.000 goroutines que dormiam 100 ms cada terminaram em 134 ms, porque a espera se sobrepõe mesmo em um único processador.
E a preempção não é instantânea. Medido: com GOMAXPROCS=1 e uma goroutine girando em um laço sem chamadas de função, uma espera de 1 ms em outra goroutine levou 21,7 ms em média e 40,8 ms no pior caso. O laço girando é preemptado, e é por isso que o programa não trava, mas quem dorme espera o fim da fatia de tempo dele. Em um servidor real, um laço pesado de CPU em todos os Ps (compressão, análise de uma entrada enorme, um cálculo apertado) aparece como picos de latência para requisições não relacionadas, não como uma falha.
3. Canais
Um canal é uma fila tipada com sincronização embutida. As regras que vale conhecer com exatidão:
| Operação | Canal sem buffer | Canal com buffer (capacidade n) |
|---|---|---|
| Enviar | espera até que um receptor esteja pronto (uma entrega direta) | espera só se o buffer estiver cheio |
| Receber | espera até que um remetente esteja pronto | espera só se o buffer estiver vazio |
| Receber de um canal fechado | devolve o valor zero na hora (v, ok dá ok == false), depois de esvaziados os valores no buffer | igual |
| Enviar para um canal fechado | panic | panic |
| Fechar um canal já fechado, ou nil | panic | panic |
| Enviar ou receber em um canal nil | bloqueia para sempre | bloqueia para sempre |
Consequências: só o remetente fecha, e somente quando há um único dono da decisão de fechar (vários remetentes precisam de um coordenador); close é um broadcast ("não há mais valores", visto por todos os receptores); e um select sobre canais escolhe aleatoriamente entre os casos prontos, então não dá prioridade. Um canal nil em um select é um truque útil: ele desativa aquele caso.
Os padrões clássicos são o pipeline (estágios ligados por canais), o pool de workers (várias goroutines lendo um canal de tarefas) e o fan-in (juntar vários canais em um). A seção 5 traz um pool de workers com cancelamento correto.
Canais, mutexes e atômicos: quanto custam
Medido: 4 goroutines somam 1 a um contador compartilhado 1.000.000 de vezes cada, em 2 CPUs, de quatro maneiras.
| Técnica | Tempo por incremento |
|---|---|
| Um contador por goroutine, somados no final | 1,4 ns |
atomic.Int64 | 16,4 ns |
sync.Mutex | 57,6 ns |
| Enviar cada incremento por um canal a uma goroutine dona | 78,0 ns |
E para passar mensagens entre duas goroutines:
| Operação | Custo |
|---|---|
| Ida e volta sem buffer (enviar, depois receber de volta) | 431 ns |
| Fluxo de mão única, sem buffer | 245 ns por mensagem |
| Fluxo de mão única, buffer de 1 | 204 ns por mensagem |
| Fluxo de mão única, buffer de 128 | 92 ns por mensagem |
Leia isso com cuidado:
- O desenho certo venceu a primitiva mais rápida por um fator de dez: dar a cada goroutine o seu próprio contador e combinar no final elimina a contenção por completo. A sincronização mais barata é nenhuma.
- Um envio em canal custa na ordem de 100 a 250 ns: baratíssimo para passar uma tarefa ou um resultado, mas caro demais para uma operação por item dentro de um laço quente (um contador, um bloqueio em volta de uma consulta a um mapa). O custo do mutex aqui vem da contenção entre goroutines em CPUs diferentes; um bloqueio sem contenção é muito mais barato.
- Um buffer reduz o custo por mensagem ao deixar remetente e receptor rodarem sem se encontrarem a cada vez.
A regra prática, muitas vezes dita como "compartilhe memória comunicando": use um canal para transferir a posse ou coordenar (tarefas, resultados, eventos, cancelamento), e um mutex ou atômico para proteger o estado que várias goroutines precisam ler e escrever (um cache, um contador, uma configuração). Um canal fazendo as vezes de um bloqueio é mais lento e mais difícil de ler do que o bloqueio.
4. Estado compartilhado, corridas de dados e o modelo de memória
Quando duas goroutines acessam a mesma variável, pelo menos uma delas escreve, e nada ordena os acessos, o programa tem uma corrida de dados (data race), e o seu comportamento é indefinido na prática. O problema não é só a perda de atualizações: o compilador e a CPU podem reordenar e guardar em cache, então uma goroutine pode nunca ver a escrita de outra.
Medido: duas goroutines incrementaram cada uma um int comum um milhão de vezes. O resultado deveria ser 2.000.000. Três execuções deram 1.716.216, 1.716.891 e 1.442.407: entre 14% e 28% das atualizações sumiram, e um número diferente a cada vez. (Com apenas 1.000 incrementos cada, três execuções deram a resposta certa, porque a primeira goroutine terminou antes de a segunda começar. Uma corrida que não aparece em um teste pequeno continua sendo uma corrida.)
A ferramenta do Go para isso é o detector de corridas, uma opção de compilação que instrumenta os acessos à memória: go test -race e go run -race. No mesmo programa, ele relata:
WARNING: DATA RACE
Read at 0x00c000112078 by goroutine 8:
main.main.func3()
main.go:85 +0x99
Previous write at 0x00c000112078 by goroutine 7:
main.main.func3()
main.go:85 +0xab
com os dois acessos conflitantes e onde as goroutines foram criadas. Ele só encontra corridas que realmente acontecem durante a execução, e deixa o programa várias vezes mais lento, então rode os seus testes com -race na CI (é a ferramenta de concorrência mais útil da linguagem) e não dependa dele em produção.
O modelo de memória do Go diz que ordenação você pode esperar. As garantias vêm de eventos de sincronização, cada um dos quais cria uma aresta happens-before (acontece antes):
- Um envio em um canal acontece antes de o recebimento correspondente terminar; fechar um canal acontece antes de um recebimento que retorna por causa do fechamento.
- O
Unlockde um mutex acontece antes de umLockposterior do mesmo mutex. wg.Doneacontece antes dewg.Waitretornar;sync.Oncetermina antes de qualquerDoretornar.- As operações atômicas são sequencialmente consistentes e sincronizam.
Sem uma aresta assim você não pode presumir que uma goroutine vê o que outra fez, mesmo que o código "obviamente" rode em sequência. Bugs típicos: uma flag lida em um laço sem sincronização (o compilador pode tirar a leitura de dentro do laço), uma global inicializada de forma preguiçosa sem sync.Once, um mapa escrito por várias goroutines.
Um mapa é o caso mais afiado. As escritas concorrentes são detectadas de forma best-effort e encerram o processo inteiro: quatro goroutines escrevendo em um mapa derrubaram este experimento com
fatal error: concurrent map writes
que é um erro fatal, não um panic, então recover não consegue capturá-lo. Proteja um mapa com um mutex (ou use sync.Map para os dois casos estreitos para os quais foi feito: chaves escritas uma vez e lidas muitas, ou goroutines trabalhando em conjuntos disjuntos de chaves).
5. Cancelamento e vazamentos de goroutines
Uma goroutine que bloqueia para sempre é um vazamento: ela nunca libera a sua pilha, e tudo a que a pilha se refere continua vivo. Vazamentos não fazem um teste falhar; aparecem como memória e contagem de goroutines que sobem devagar em produção. A causa mais comum é uma goroutine bloqueada em uma operação de canal que ninguém vai completar.
O experimento chama uma função 10.000 vezes; cada chamada inicia um worker que leva 5 ms e desiste depois de 1 ms. Na versão com vazamento, o worker envia o resultado por um canal sem buffer; depois do timeout ninguém recebe, então o envio bloqueia para sempre.
| Versão | Goroutines antes → depois de 10.000 chamadas | Memória extra do sistema |
|---|---|---|
| Canal de resultado sem buffer | 1 → 10.001 | +29,9 MB |
| Canal de resultado com buffer de um | 1 → 1 | +4,8 MB |
A correção foi um único caractere, make(chan int, 1): um buffer de um permite que o worker complete o seu envio e saia, quer alguém esteja escutando ou não. Cerca de 3 KB por goroutine vazada, multiplicados por toda requisição que expirou durante a vida do processo.
A ferramenta geral é o context.Context: um valor que carrega um sinal de cancelamento (e um prazo) por uma árvore de chamadas. As regras:
- Passe
ctxcomo primeiro parâmetro de toda função que possa bloquear ou demorar, e repasse-o. Não o guarde em uma struct. - Todo comando
goprecisa de uma resposta para "o que o para?": o canal que ele lê é fechado, ou ele observactx.Done(), ou o trabalho dele é limitado. - Toda operação de canal bloqueante em uma goroutine que pode ser cancelada deve estar em um
selectcomctx.Done(). - Quem cria um contexto com
WithCancelouWithTimeoutdeve chamar a funçãocancel(normalmentedefer cancel()). - Espere as goroutines terminarem (
sync.WaitGroup) antes de retornar da função que as iniciou, para que nenhum trabalho sobreviva ao seu chamador.
A listagem abaixo põe essas regras em um pool de workers que para no primeiro erro e quando o seu pai é cancelado, e que só retorna depois de todos os workers terem saído. (Ela compila e foi executada sob o detector de corridas, com uma tarefa que falha e com uma execução limpa.)
// process runs handle for every job with a fixed number of workers. The first error stops the rest;
// cancelling the parent context does too. It returns only after every worker has exited.
func process(parent context.Context, jobs []string, workers int, handle func(context.Context, string) error) error {
ctx, cancel := context.WithCancel(parent)
defer cancel()
in := make(chan string)
firstErr := make(chan error, 1) // buffered, so a failing worker never blocks while reporting
var wg sync.WaitGroup
for w := 0; w < workers; w++ {
wg.Add(1)
go func() {
defer wg.Done()
for job := range in {
if err := handle(ctx, job); err != nil {
select {
case firstErr <- err:
default: // another worker already reported
}
cancel() // tell the producer and the other workers to stop
return
}
}
}()
}
feed:
for _, job := range jobs {
select {
case in <- job:
case <-ctx.Done(): // never block on a send without also watching for cancellation
break feed
}
}
close(in) // the sender closes, so the workers' range loops end
wg.Wait()
select {
case err := <-firstErr:
return err
default:
return parent.Err()
}
}
Para encontrar vazamentos em um serviço em execução, observe a contagem de goroutines ao longo do tempo (runtime.NumGoroutine() como métrica) e o perfil de pilhas de goroutines (o perfil goroutine do pprof as agrupa pelo ponto em que estão bloqueadas, o que costuma apontar direto para o vazamento).
6. Onde os valores vivem: pilha, heap e análise de escape
O Go não tem, na sintaxe, uma distinção entre new e pilha. O compilador decide, pela análise de escape, se uma variável pode viver na pilha da goroutine (liberada sem custo quando a função retorna, nunca vista pelo coletor de lixo) ou se precisa ir para o heap (alocada pelo runtime e liberada depois pelo coletor de lixo). Um valor escapa quando o compilador não consegue provar que nada se refere a ele depois que a função retorna. Você pode perguntar ao compilador o que ele decidiu com go build -gcflags='-m -l' (o -l desativa o inlining para que a saída fique mais fácil de ler). Para as funções do apêndice:
./main.go:15:2: moved to heap: p (byPointer: returns &p)
./main.go:21:13: make([]int, 8) does not escape (localSum: small, constant size, stays inside)
./main.go:34:13: make([]int, n) escapes to heap (dynamic: size unknown at compile time)
./main.go:40:14: n escapes to heap (printIt: stored in an interface for fmt.Println)
./main.go:47:24: func literal escapes to heap (capture: a closure that outlives the call)
Os motivos usuais para um valor escapar: o seu endereço é devolvido ou guardado em algum lugar que sobrevive à função; ele é colocado em uma interface (boxing); é capturado por uma closure que escapa; o seu tamanho não é uma constante de compilação ou é grande; ou é passado a uma função em cujo interior o compilador não enxerga (um método de interface ou um valor de função).
Por que se importar? A alocação no heap custa tempo na hora de alocar e trabalho para o coletor de lixo depois. Medido com testing.Benchmark em uma goroutine:
| Operação | Tempo por operação | Memória por operação | Alocações |
|---|---|---|---|
| Devolver uma struct pequena por valor | 1,0 ns | 0 | 0 |
| Devolver um ponteiro que sobrevive à chamada | 26 ns | 24 B | 1 |
Colocar um int maior que 255 em uma interface | 14 ns | 8 B | 1 |
| Acrescentar 1.000 ints a um slice nil | 9.150 ns | 25.208 B | 12 |
Acrescentar 1.000 ints a make([]int, 0, 1000) | 542 ns | 0 | 0 |
Montar uma string de 1.000 partes com += | 224.025 ns | 530.275 B | 999 |
O mesmo com strings.Builder | 2.591 ns | 3.320 B | 9 |
Um buffer de 4 KB por chamada que escapa: make | 1.424 ns | 4.096 B | 1 |
O mesmo buffer vindo de um sync.Pool | 27 ns | 0 | 0 |
As lições, na ordem de quão frequentemente importam:
- Pré-aloque slices e mapas quando souber o tamanho (
make([]T, 0, n)). Crescer com append copia os dados de novo e de novo: 12 alocações e 17 vezes o tempo aqui. (O slice pré-alocado de 1.000 ints nem chegou ao heap: tem tamanho constante e não escapa.) - Monte strings com
strings.Builder(oubytes.Buffer), nunca com+=em um laço, que é quadrático: cada passo copia a string inteira de novo. - Um
sync.Poolreutiliza objetos temporários (buffers, codificadores), levando uma alocação de 4 KB de 1,4 µs para 27 ns. O pool pode descartar o conteúdo a qualquer coleta, então é um cache de objetos de rascunho, nunca um lugar para guardar estado; e sempre zere o que você retira. - Ponteiros não são "mais rápidos". Passar uma struct pequena por valor costuma ser mais barato do que passar um ponteiro, porque o valor fica na pilha e o coletor nunca o vê. Use ponteiros para structs grandes, para coisas que precisam ser mutadas e quando a identidade importa.
- Meça antes de otimizar, usando
go test -bench -benchmeme a saída de escape, e olhe o heap com opprof. Uma alocação dentro de uma função que roda duas vezes por segundo não é o problema.
7. O coletor de lixo
O coletor do Go é concorrente, não móvel, de marcação e varredura tricolor, e não é geracional. Ele marca os objetos alcançáveis a partir das raízes (pilhas e globais) enquanto as suas goroutines continuam rodando, com breves pausas de parada total (stop-the-world) no início e no fim de um ciclo (em geral bem abaixo de um milissegundo), e depois libera o resto. Como roda de forma concorrente, o seu custo não são principalmente as pausas: é CPU. O coletor usa cerca de um quarto das CPUs durante a marcação e, quando uma goroutine aloca mais rápido do que o coletor consegue acompanhar, essa goroutine é obrigada a ajudar ("assist"), o que a deixa mais lenta.
A configuração central é o GOGC (padrão 100): um novo ciclo começa quando o heap cresceu GOGC por cento sobre o heap vivo medido após o ciclo anterior. Com 200 MB de dados vivos e GOGC=100, o heap pode crescer até cerca de 400 MB antes da próxima coleta; com GOGC=400, até cerca de 1 GB. Um valor maior significa menos coletas e mais memória; um valor menor, o contrário. Desde o Go 1.19 há também o GOMEMLIMIT, um limite flexível para a memória total: à medida que o processo se aproxima dele, o coletor roda com mais frequência, então o limite evita que o processo seja morto por falta de memória, mas pode fazer o programa passar a maior parte do tempo coletando.
Medido: um programa mantém 200 MB de dados vivos (200.000 objetos de 1 KB) e duas goroutines alocam 4 milhões de objetos de 1 KB de vida curta (cerca de 4 GB no total). Medianas de três execuções:
| Configuração | Tempo total | Coletas | Pausa total de parada total | Pico de memória do sistema |
|---|---|---|---|---|
GOGC=50 | 1.061 ms | 36 | 3,4 ms | 386 MB |
GOGC=100 (padrão) | 888 ms | 17 | 1,7 ms | 558 MB |
GOGC=200 | 793 ms | 9 | 0,8 ms | 813 MB |
GOGC=400 | 936 ms | 5 | 0,6 ms | 1.275 MB |
GOGC=800 | 1.030 ms | 3 | 0,3 ms | 2.181 MB |
GOGC=off, GOMEMLIMIT=300MiB | 1.351 ms | 63 | 5,9 ms | 330 MB |
O que isso mostra:
- As pausas não são o custo. Mesmo com 63 coletas, a pausa total foi de poucos milissegundos em mais de um segundo de trabalho. Um serviço Go tem muito mais chance de sofrer com a CPU gasta coletando do que com pausas de parada total.
- Há uma troca de memória por tempo, e ela se achata: ir de 50 para 200 deu uma execução 25% mais curta por 2,1 vezes a memória, e acima de 200 a memória extra não comprou nada (memória nova tem o seu próprio custo: falhas de página). O padrão é um meio-termo sensato.
- Um limite de memória apertado é caro: limitar o processo a apenas 100 MB acima dos seus dados vivos fez o coletor rodar 63 vezes, e a execução levou 50% mais tempo do que com o padrão. Deixe uma folga de pelo menos uma fração do heap vivo, ou reduza o que você aloca.
A melhor maneira de acelerar o coletor é, portanto, a seção anterior: alocar menos e manter menos ponteiros. Menos objetos significam menos a marcar. Grandes arrays de dados sem ponteiros ([]int, []byte) custam muito menos para varrer do que slices de ponteiros ou de structs que contêm ponteiros. Para ver o que o coletor está fazendo, rode com GODEBUG=gctrace=1 (uma linha por ciclo, com os tamanhos do heap e o tempo de CPU) e use runtime.ReadMemStats ou o pacote runtime/metrics para obter números em produção.
8. Comportamentos da linguagem que surpreendem
O pequeno programa do apêndice imprime cada um destes.
- A variável do laço. Antes do Go 1.22, todas as iterações de um laço
forcompartilhavam uma única variável, então goroutines iniciadas em um laço viam todas o último valor. Desde o Go 1.22 (quando a linhagodogo.modé 1.22 ou posterior), cada iteração tem a sua própria cópia. Este experimento iniciou três goroutines em um laço e elas viram[0 1 2]. Se o seu módulo declara uma versão mais antiga do Go, o comportamento antigo continua valendo: verifique ogo.mod. - Slices compartilham memória. Um slice é um pequeno cabeçalho (ponteiro, tamanho, capacidade) sobre um array.
b := a[:2]compartilha o array dea, eappend(b, 99)escreve na memória dease a capacidade permitir. O experimento imprimiua = [0 0 99] b = [0 0 99]para um slice com capacidade sobrando, ec = [1 2 99] d = [1 2 99]para um slice comum de três elementos, porque o sub-slicec[:2]ainda tem espaço até o fim do array dec. Quando uma função guarda ou devolve um sub-slice, copie se o chamador não deve ver mudanças posteriores:append([]int(nil), c[:2]...)imprimiu um[1 2 100]independente e deixoucem paz. Um pequeno sub-slice retido também mantém vivo o array grande inteiro. - Um ponteiro nil em uma interface não é uma interface nil. Um valor de interface guarda um tipo e um valor, e só é igual a
nilse ambos estiverem vazios. Uma função que declaravar e *myErre a devolve comoerrordevolve um erro não nil mesmo quando o ponteiro é nil:mayFail(false) == nilimprimiufalse. Devolva o literalnil. deferavalia os seus argumentos quando o comandodeferé executado, não quando a função termina, e as chamadas adiadas rodam na ordem inversa. Umdeferdentro de um laço roda quando a função retorna, não quando a iteração termina, então adiarCloseem um laço mantém todos os arquivos abertos até o fim.- Mapas não podem ser usados de forma concorrente (seção 4), a ordem de iteração é deliberadamente aleatória, e ler uma chave ausente devolve o valor zero: use
v, ok := m[k]quando a diferença importar. - Erros são valores. Embrulhe-os com
fmt.Errorf("...: %w", err)e teste comerrors.Iseerrors.As; não compare textos de erro. Usepanicpara erros do programador e estados impossíveis, não para falhas esperadas, erecoverapenas na fronteira de uma goroutine ou de uma requisição.
9. Qual ferramenta para qual pergunta
| Pergunta | Ferramenta |
|---|---|
| Há uma corrida de dados? | go test -race, go run -race |
| Para onde vai o tempo (CPU)? | perfil de CPU do pprof (net/http/pprof, ou go test -cpuprofile) |
| Quem aloca, e quanto? | perfis de heap e de alocações do pprof; go test -bench -benchmem |
| O compilador moveu isto para o heap? | go build -gcflags='-m -l' |
| Goroutines estão se acumulando, e onde estão presas? | perfil goroutine do pprof; runtime.NumGoroutine() como métrica |
| Por que a latência é irregular (escalonamento, coleta, bloqueio)? | go tool trace (o rastreador de execução) |
| O que o coletor está fazendo? | GODEBUG=gctrace=1, runtime/metrics |
| Esta mudança é mesmo mais rápida? | um benchmark, rodado várias vezes, comparado com benchstat |
10. Erros comuns
- Iniciar goroutines sem um jeito de pará-las, ou com um canal do qual ninguém vai receber (seção 5). Procure cada
goe pergunte o que o encerra. - Concorrência ilimitada: uma goroutine por item de uma entrada grande, martelando um banco de dados ou uma API. Use um pool de workers ou um semáforo.
- Compartilhar uma variável entre goroutines sem sincronização, inclusive uma flag ou um contador "inofensivo". Rode os testes com
-race. - Usar canais onde um mutex é mais simples, ou um mutex mantido durante uma chamada lenta (uma requisição de rede), de modo que todas as outras goroutines esperam.
- Fechar um canal pelo receptor, ou por vários remetentes, causando um panic.
- Esquecer que o panic de uma goroutine encerra o programa, a menos que seja recuperado dentro dessa goroutine: o
recoverno pai não ajuda. - Capturar a variável do laço em código no estilo antigo, ou ignorar a versão
gonogo.mod. - Vazar com
time.Afterem um laço quente, timers que não são parados, tickers que não são parados (ticker.Stop()), corpos de resposta que não são fechados. - Montar strings com
+=e slices sem capacidade em caminhos quentes. - Ajustar o coletor primeiro. Reduza as alocações antes de mexer no
GOGC, e use oGOMEMLIMITcomo uma rede de segurança, não como um modo de vida. - Ler um benchmark como uma lei. As proporções aqui são específicas deste hardware e destes programas. Meça o seu próprio caso.
11. O que mencionar em uma entrevista
- Explique o modelo G, M, P em duas frases: as goroutines são multiplexadas em threads do SO, uma thread precisa de um P para executar código Go, Ps ociosos roubam trabalho, e a E/S de rede bloqueada estaciona a goroutine, não a thread.
- Dê o custo de uma goroutine (cerca de 2 KB de pilha, microssegundos para iniciar), e diga que mesmo assim você limita a concorrência.
- Declare as regras dos canais (o sem buffer sincroniza, enviar para um fechado dá panic, só o remetente fecha, nil bloqueia para sempre,
selecté aleatório) e quando preferir um mutex ou atômico. - Descreva um vazamento de goroutine, como você o encontraria (perfil de goroutines,
NumGoroutine) e comocontexte canais com buffer o evitam. - Mencione o detector de corridas e as regras de happens-before do modelo de memória.
- Explique a análise de escape com um exemplo (devolver
&x, interfaces, closures) e como você a verificaria (-gcflags=-m). - Descreva o coletor: marcação e varredura concorrentes, pausas curtas, o custo é CPU;
GOGCtroca memória por tempo,GOMEMLIMITé um teto flexível; aloque menos primeiro. - Conheça as armadilhas: a variável do laço (Go 1.22), o aliasing de slices, a interface nil, escritas concorrentes em mapas serem fatais.
- Cite números das suas próprias medições; isso mostra que você confere.
Resumo rápido
- Goroutines custam cerca de 2,6 KB e alguns microssegundos. Baratas, mas não de graça e não limitadas: limite a concorrência e dê a toda goroutine um fim.
- O escalonador roda Gs em Ms com um P cada; esperas de rede estacionam a goroutine, Ps ociosos roubam trabalho, laços longos são preemptados após cerca de 10 ms (medido: uma espera de 1 ms levou 22 ms atrás de um laço girando).
- Canais transferem a posse e coordenam (cerca de 100 a 250 ns por mensagem); mutexes e atômicos protegem estado (57 e 16 ns sob contenção); nenhum compartilhamento foi 1,4 ns.
- Corridas de dados perdem atualizações em silêncio (medido: 14 a 28% delas); rode
go test -race. - Vazamentos: um envio sem buffer que ninguém recebe vazou 10.001 goroutines e 30 MB; um buffer de um resolveu. Use
contexteselectemctx.Done(). - A análise de escape decide pilha ou heap; pré-aloque (17 vezes mais rápido), use
strings.Builder(86 vezes mais rápido) e umsync.Poolpara buffers de rascunho (27 ns em vez de 1,4 µs). - O custo do coletor é CPU, não pausas.
GOGCtroca memória por tempo; umGOMEMLIMITapertado deixou a execução 50% mais lenta. Aloque menos primeiro. - Armadilhas: variáveis de laço (corrigidas no Go 1.22), slices compartilham memória, um ponteiro nil em uma interface não é nil, escritas concorrentes em mapas são fatais.
Apêndice: o código
Os números vêm de quatro programas, todos usando apenas a biblioteca padrão e o Go 1.24. O goexp contém os experimentos de runtime, um por comando: go run . gcost, sched, sync, leak leaky, leak fixed, alloc e gc (execute o último com as configurações no ambiente, por exemplo GOGC=200 go run . gc, ou GOGC=off GOMEMLIMIT=300MiB go run . gc). O escape é o arquivo cuja análise de escape é citada na seção 6 (go build -gcflags='-m -l'). O gotchas imprime os comportamentos da seção 8 (go run . loopvar, slice, nilerr, mapcrash, race, e go run -race . race para o detector). Note que o go.mod do módulo precisa dizer go 1.22 ou posterior para o resultado da variável do laço.
goexp/main.go
// goexp: small experiments on the Go runtime. Usage: go run . gcost|sched|sync|leak leaky|leak fixed|alloc|gc
package main
import (
"crypto/sha256"
"fmt"
"io"
"os"
"runtime"
"runtime/debug"
"strconv"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
)
func ms(d time.Duration) float64 { return float64(d.Microseconds()) / 1000 }
// ---------- 1. What a goroutine costs ----------
func gcost() {
fmt.Println("goroutines parked on a channel: memory taken and time to start them")
for _, n := range []int{1_000, 100_000, 1_000_000} {
runtime.GC()
var a, b runtime.MemStats
runtime.ReadMemStats(&a)
stop := make(chan struct{})
var started sync.WaitGroup
started.Add(n)
t := time.Now()
for i := 0; i < n; i++ {
go func() { started.Done(); <-stop }()
}
started.Wait()
el := time.Since(t)
runtime.ReadMemStats(&b)
fmt.Printf(" %9d goroutines: %7.1f ms to start all (%.2f us each), %6.1f MB from the system = %.2f KB each (stacks in use: %.2f KB each)\n",
n, ms(el), float64(el.Nanoseconds())/float64(n)/1000, float64(b.Sys-a.Sys)/1e6, float64(b.Sys-a.Sys)/float64(n)/1024,
float64(b.StackInuse-a.StackInuse)/float64(n)/1024)
close(stop)
time.Sleep(200 * time.Millisecond)
}
}
// ---------- 2. The scheduler ----------
func burn(rounds int) {
var buf [32]byte
for i := 0; i < rounds; i++ {
buf = sha256.Sum256(buf[:])
}
}
func sched() {
fmt.Printf("this machine: %d logical CPUs\n", runtime.NumCPU())
const total = 400_000 // SHA-256 rounds, split over goroutines
for _, procs := range []int{1, 2, 4} {
runtime.GOMAXPROCS(procs)
for _, g := range []int{1, 2, 8} {
var wg sync.WaitGroup
t := time.Now()
for i := 0; i < g; i++ {
wg.Add(1)
go func() { defer wg.Done(); burn(total / g) }()
}
wg.Wait()
fmt.Printf(" GOMAXPROCS=%d, %d goroutine(s) sharing the same CPU work: %7.1f ms\n", procs, g, ms(time.Since(t)))
}
}
runtime.GOMAXPROCS(1)
// Concurrency without parallelism: 10,000 goroutines that each wait 100 ms
var wg sync.WaitGroup
t := time.Now()
for i := 0; i < 10_000; i++ {
wg.Add(1)
go func() { defer wg.Done(); time.Sleep(100 * time.Millisecond) }()
}
wg.Wait()
fmt.Printf("GOMAXPROCS=1: 10,000 goroutines that each sleep 100 ms finish in %.0f ms (waiting overlaps)\n", ms(time.Since(t)))
// Preemption: a goroutine in a loop with no function calls and no waiting, on a single P
var spin atomic.Bool
spin.Store(true)
go func() {
x := 0
for spin.Load() { // plain loop, no blocking call
x++
}
}()
time.Sleep(10 * time.Millisecond) // let the spinner start
var worst, sum time.Duration
const reps = 20
for i := 0; i < reps; i++ {
t = time.Now()
time.Sleep(time.Millisecond)
d := time.Since(t)
sum += d
if d > worst {
worst = d
}
}
fmt.Printf("GOMAXPROCS=1 with a goroutine spinning in a loop: a 1 ms sleep took %.1f ms on average, %.1f ms at worst (the spinner is preempted, but only after its time slice)\n",
ms(sum)/reps, ms(worst))
spin.Store(false)
runtime.GOMAXPROCS(runtime.NumCPU())
}
// ---------- 3. Channels, mutexes and atomics ----------
func syncCosts() {
const workers, perWorker = 4, 1_000_000
total := workers * perWorker
run := func(name string, f func(inc func())) {
t := time.Now()
f(nil)
el := time.Since(t)
fmt.Printf(" %-44s %8.1f ms %6.1f ns per increment\n", name, ms(el), float64(el.Nanoseconds())/float64(total))
}
fmt.Printf("%d goroutines each add 1 to a shared counter %d times (%d CPUs)\n", workers, perWorker, runtime.NumCPU())
run("sync.Mutex", func(func()) {
var mu sync.Mutex
var n int
var wg sync.WaitGroup
for w := 0; w < workers; w++ {
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < perWorker; i++ {
mu.Lock()
n++
mu.Unlock()
}
}()
}
wg.Wait()
if n != total {
panic("lost updates")
}
})
run("atomic.Int64", func(func()) {
var n atomic.Int64
var wg sync.WaitGroup
for w := 0; w < workers; w++ {
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < perWorker; i++ {
n.Add(1)
}
}()
}
wg.Wait()
if n.Load() != int64(total) {
panic("lost updates")
}
})
run("one counter per goroutine, summed at the end", func(func()) {
parts := make([]struct {
n int
_ [56]byte // padding so each counter has its own cache line
}, workers)
var wg sync.WaitGroup
for w := 0; w < workers; w++ {
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < perWorker; i++ {
parts[w].n++
}
}()
}
wg.Wait()
sum := 0
for _, p := range parts {
sum += p.n
}
if sum != total {
panic("lost updates")
}
})
run("send each increment over a channel to one owner", func(func()) {
ch := make(chan int, 256)
done := make(chan int)
go func() {
n := 0
for v := range ch {
n += v
}
done <- n
}()
var wg sync.WaitGroup
for w := 0; w < workers; w++ {
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < perWorker; i++ {
ch <- 1
}
}()
}
wg.Wait()
close(ch)
if <-done != total {
panic("lost updates")
}
})
fmt.Println("channel hand-off between two goroutines")
const msgs = 1_000_000
{ // unbuffered ping-pong
ping, pong := make(chan int), make(chan int)
go func() {
for v := range ping {
pong <- v
}
close(pong)
}()
t := time.Now()
for i := 0; i < msgs/10; i++ {
ping <- i
<-pong
}
el := time.Since(t)
close(ping)
fmt.Printf(" unbuffered round trip (send and receive back): %6.0f ns per round trip\n", float64(el.Nanoseconds())/float64(msgs/10))
}
for _, size := range []int{0, 1, 128} { // one-way stream
ch := make(chan int, size)
done := make(chan struct{})
go func() {
for range ch {
}
close(done)
}()
t := time.Now()
for i := 0; i < msgs; i++ {
ch <- i
}
close(ch)
<-done
el := time.Since(t)
fmt.Printf(" one-way stream, buffer %3d: %6.0f ns per message (%.1f million per second)\n", size, float64(el.Nanoseconds())/msgs, msgs/el.Seconds()/1e6)
}
}
// ---------- 4. A goroutine leak ----------
func slowCompute() int { time.Sleep(5 * time.Millisecond); return 42 }
// fetchLeaky gives up after 1 ms, but the worker is left blocked on an unbuffered send nobody will receive.
func fetchLeaky() int {
ch := make(chan int)
go func() { ch <- slowCompute() }()
select {
case v := <-ch:
return v
case <-time.After(time.Millisecond):
return -1
}
}
// fetchFixed is the same with a buffer of one, so the worker can always finish its send and exit.
func fetchFixed() int {
ch := make(chan int, 1)
go func() { ch <- slowCompute() }()
select {
case v := <-ch:
return v
case <-time.After(time.Millisecond):
return -1
}
}
func leak(variant string) {
f, name := fetchLeaky, "unbuffered channel (leaks)"
if variant == "fixed" {
f, name = fetchFixed, "channel with a buffer of one"
}
runtime.GC()
var a, b runtime.MemStats
runtime.ReadMemStats(&a)
before := runtime.NumGoroutine()
for i := 0; i < 10_000; i++ {
f()
}
time.Sleep(100 * time.Millisecond) // let finished workers exit
runtime.GC()
runtime.ReadMemStats(&b)
fmt.Printf(" %-30s after 10,000 timed-out calls: goroutines %6d -> %6d, memory from the system +%.1f MB\n",
name, before, runtime.NumGoroutine(), float64(b.Sys-a.Sys)/1e6)
}
// ---------- 5. Allocation: stack, heap, and what to do about it ----------
type point struct{ x, y, z float64 }
//go:noinline
func newPointValue(i int) point { return point{float64(i), 1, 2} }
var sink *point
//go:noinline
func newPointPtr(i int) *point { return &point{float64(i), 1, 2} } // escapes: the caller keeps the pointer
var sinkAny any
func bench(name string, f func(b *testing.B)) {
r := testing.Benchmark(f)
fmt.Printf(" %-52s %9.1f ns/op %6d B/op %4d allocs/op\n", name, float64(r.NsPerOp()), r.AllocedBytesPerOp(), r.AllocsPerOp())
}
func alloc() {
fmt.Println("allocation costs (testing.Benchmark, one goroutine)")
bench("return a struct by value", func(b *testing.B) {
b.ReportAllocs()
var s float64
for i := 0; i < b.N; i++ {
s += newPointValue(i).x
}
_ = s
})
bench("return a pointer that outlives the call", func(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
sink = newPointPtr(i)
}
})
const n = 1000
bench("append 1,000 ints, no preallocation", func(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
var s []int
for j := 0; j < n; j++ {
s = append(s, j)
}
_ = s
}
})
bench("append 1,000 ints, make([]int, 0, 1000)", func(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
s := make([]int, 0, n)
for j := 0; j < n; j++ {
s = append(s, j)
}
_ = s
}
})
bench("build a string of 1,000 parts with +=", func(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
s := ""
for j := 0; j < n; j++ {
s += "x"
}
_ = s
}
})
bench("build a string of 1,000 parts with strings.Builder", func(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
var sb strings.Builder
for j := 0; j < n; j++ {
sb.WriteByte('x')
}
_ = sb.String()
}
})
bench("put an int > 255 in an interface (boxing)", func(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
sinkAny = i + 1000
}
})
pool := sync.Pool{New: func() any { b := make([]byte, 0, 4096); return &b }}
bench("a 4 KB scratch buffer per call: make (escapes)", func(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
buf := make([]byte, 0, 4096)
buf = strconv.AppendInt(buf, int64(i), 10)
out.Write(buf) // an interface call: the compiler cannot prove the buffer is not kept, so it goes to the heap
}
})
bench("a 4 KB scratch buffer per call: sync.Pool", func(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
bp := pool.Get().(*[]byte)
buf := strconv.AppendInt((*bp)[:0], int64(i), 10)
out.Write(buf)
*bp = buf
pool.Put(bp)
}
})
}
var out io.Writer = io.Discard
// ---------- 6. The garbage collector: GOGC and memory ----------
var keep [][]byte
func gcRun() {
// A live heap of about 200 MB that stays, plus a stream of short-lived 1 KB objects.
for i := 0; i < 200_000; i++ {
keep = append(keep, make([]byte, 1024))
}
var before runtime.MemStats
runtime.ReadMemStats(&before)
t := time.Now()
var wg sync.WaitGroup
for w := 0; w < 2; w++ {
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < 2_000_000; i++ {
b := make([]byte, 1024)
b[0] = byte(i)
out.Write(b[:1]) // escapes: the object is allocated on the heap
}
}()
}
wg.Wait()
el := time.Since(t)
var after runtime.MemStats
runtime.ReadMemStats(&after)
fmt.Printf("GOGC=%-4s GOMEMLIMIT=%-6s %7.0f ms collections %4d total pause %6.1f ms peak memory from the system %5.0f MB\n",
os.Getenv("GOGC"), orDash(os.Getenv("GOMEMLIMIT")), ms(el), after.NumGC-before.NumGC,
float64(after.PauseTotalNs-before.PauseTotalNs)/1e6, float64(after.Sys)/1e6)
_ = debug.SetGCPercent
}
func orDash(s string) string {
if s == "" {
return "-"
}
return s
}
func main() {
if len(os.Args) < 2 {
fmt.Println("usage: goexp gcost|sched|sync|leak leaky|leak fixed|alloc|gc")
return
}
switch os.Args[1] {
case "gcost":
gcost()
case "sched":
sched()
case "sync":
syncCosts()
case "leak":
leak(os.Args[2]) // "leaky" or "fixed"
case "alloc":
alloc()
case "gc":
gcRun()
}
}
escape/main.go
package main
import "fmt"
type point struct{ x, y int }
// stays on the stack: the value is copied to the caller
func byValue() point {
p := point{1, 2}
return p
}
// escapes: the caller receives a pointer to a variable that must outlive this call
func byPointer() *point {
p := point{1, 2}
return &p
}
// does not escape: the slice is small, of constant size, and does not leave the function
func localSum() int {
buf := make([]int, 8)
for i := range buf {
buf[i] = i
}
s := 0
for _, v := range buf {
s += v
}
return s
}
// escapes: the size is not known at compile time
func dynamic(n int) []int {
buf := make([]int, n)
return buf[:1]
}
// escapes: the value is stored in an interface that is passed on (fmt.Println takes ...any)
func printIt(n int) {
fmt.Println(n)
}
var saved []func() int
// escapes: the closure outlives the call and captures i
func capture(i int) {
saved = append(saved, func() int { return i })
}
func main() {
_ = byValue()
_ = byPointer()
_ = localSum()
_ = dynamic(100)
printIt(7)
capture(1)
}
gotchas/main.go
// gotchas: five Go behaviours that surprise people. Usage: go run . loopvar|slice|nilerr|mapcrash|race
package main
import (
"fmt"
"os"
"sort"
"sync"
)
type myErr struct{}
func (*myErr) Error() string { return "my error" }
func mayFail(fail bool) error {
var e *myErr // a nil pointer of a concrete type
if fail {
e = &myErr{}
}
return e // BUG: a non-nil interface holding a nil pointer when fail is false
}
func mayFailFixed(fail bool) error {
if fail {
return &myErr{}
}
return nil
}
func main() {
switch os.Args[1] {
case "loopvar":
var wg sync.WaitGroup
var mu sync.Mutex
var seen []int
for i := 0; i < 3; i++ {
wg.Add(1)
go func() {
defer wg.Done()
mu.Lock()
seen = append(seen, i) // since Go 1.22 each iteration has its own i
mu.Unlock()
}()
}
wg.Wait()
sort.Ints(seen)
fmt.Println("goroutines saw i =", seen)
case "slice":
a := make([]int, 3, 10)
b := a[:2]
b = append(b, 99) // fits in the capacity of a, so it overwrites a[2]
fmt.Println("a =", a, "b =", b)
c := []int{1, 2, 3}
d := c[:2]
d = append(d, 99) // also fits: capacity of c is 3
fmt.Println("c =", c, "d =", d)
e := append([]int(nil), c[:2]...) // a copy: independent memory
e = append(e, 100)
fmt.Println("c =", c, "e =", e)
case "nilerr":
fmt.Println("mayFail(false) == nil:", mayFail(false) == nil)
fmt.Println("mayFailFixed(false) == nil:", mayFailFixed(false) == nil)
case "mapcrash":
m := map[int]int{}
var wg sync.WaitGroup
for g := 0; g < 4; g++ {
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < 100000; i++ {
m[i%1000] = i
}
}()
}
wg.Wait()
fmt.Println("finished without a crash (not guaranteed)")
case "race":
var n int
var wg sync.WaitGroup
for g := 0; g < 2; g++ {
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < 1_000_000; i++ {
n++
}
}()
}
wg.Wait()
fmt.Println("n =", n, "(expected 2000000)")
}
}
Fontes
- The Go Authors, The Go Memory Model, as regras de happens-before para canais, mutexes,
sync.Once,WaitGroupe atômicos. - The Go Authors, A Guide to the Go Garbage Collector:
GOGC,GOMEMLIMIT, e como o custo da coleta é modelado. - Dmitry Vyukov, Scalable Go Scheduler Design Doc (o modelo G, M, P e o roubo de trabalho), e as notas de versão do Go 1.14 (preempção assíncrona).
- The Go Authors, Frequently Asked Questions: how do I know whether a variable is allocated on the heap or the stack?
- The Go Authors, Data Race Detector.
- Sameer Ajmani, Go Concurrency Patterns: Context e Go Concurrency Patterns: Pipelines and cancellation.
- David Chase e Russ Cox, Fixing For Loops in Go 1.22, e Andrew Gerrand, Go Slices: usage and internals.
- The Go Authors, package runtime (
GOMAXPROCS,GOGC,GOMEMLIMIT,GODEBUG) e Effective Go. - Katherine Cox-Buday, Concurrency in Go (O'Reilly, 2017), e Teiva Harsanyi, 100 Go Mistakes and How to Avoid Them (Manning, 2022).
Pratique este tema: Go