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 de go 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:

Medido: goroutines foram iniciadas e estacionadas em um canal, e a memória ocupada foi lida do runtime.

GoroutinesTempo para iniciar todasPor goroutinePilha em uso por goroutineMemória do sistema, por goroutine
1.0001,7 ms1,7 µs1,98 KB
100.000241 ms2,4 µs2,02 KB2,65 KB (271 MB no total)
1.000.0003,4 s3,4 µs2,20 KB2,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í:

  1. 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.
  2. 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:

Medido: 400.000 rodadas de SHA-256, divididas entre goroutines, com GOMAXPROCS diferentes em uma máquina de 2 CPUs.

GOMAXPROCSGoroutines dividindo o trabalhoTempo
11, 2 ou 840 ms, 42 ms, 40 ms
2140 ms (uma goroutine só consegue usar uma CPU)
22 ou 822 ms, 21 ms (cerca de duas vezes mais rápido)
42 ou 822 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çãoCanal sem bufferCanal com buffer (capacidade n)
Enviarespera até que um receptor esteja pronto (uma entrega direta)espera só se o buffer estiver cheio
Receberespera até que um remetente esteja prontoespera só se o buffer estiver vazio
Receber de um canal fechadodevolve o valor zero na hora (v, ok dá ok == false), depois de esvaziados os valores no bufferigual
Enviar para um canal fechadopanicpanic
Fechar um canal já fechado, ou nilpanicpanic
Enviar ou receber em um canal nilbloqueia para semprebloqueia 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écnicaTempo por incremento
Um contador por goroutine, somados no final1,4 ns
atomic.Int6416,4 ns
sync.Mutex57,6 ns
Enviar cada incremento por um canal a uma goroutine dona78,0 ns

E para passar mensagens entre duas goroutines:

OperaçãoCusto
Ida e volta sem buffer (enviar, depois receber de volta)431 ns
Fluxo de mão única, sem buffer245 ns por mensagem
Fluxo de mão única, buffer de 1204 ns por mensagem
Fluxo de mão única, buffer de 12892 ns por mensagem

Leia isso com cuidado:

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):

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ãoGoroutines antes → depois de 10.000 chamadasMemória extra do sistema
Canal de resultado sem buffer1 → 10.001+29,9 MB
Canal de resultado com buffer de um1 → 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:

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çãoTempo por operaçãoMemória por operaçãoAlocações
Devolver uma struct pequena por valor1,0 ns00
Devolver um ponteiro que sobrevive à chamada26 ns24 B1
Colocar um int maior que 255 em uma interface14 ns8 B1
Acrescentar 1.000 ints a um slice nil9.150 ns25.208 B12
Acrescentar 1.000 ints a make([]int, 0, 1000)542 ns00
Montar uma string de 1.000 partes com +=224.025 ns530.275 B999
O mesmo com strings.Builder2.591 ns3.320 B9
Um buffer de 4 KB por chamada que escapa: make1.424 ns4.096 B1
O mesmo buffer vindo de um sync.Pool27 ns00

As lições, na ordem de quão frequentemente importam:

  1. 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.)
  2. Monte strings com strings.Builder (ou bytes.Buffer), nunca com += em um laço, que é quadrático: cada passo copia a string inteira de novo.
  3. Um sync.Pool reutiliza 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.
  4. 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.
  5. Meça antes de otimizar, usando go test -bench -benchmem e a saída de escape, e olhe o heap com o pprof. 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çãoTempo totalColetasPausa total de parada totalPico de memória do sistema
GOGC=501.061 ms363,4 ms386 MB
GOGC=100 (padrão)888 ms171,7 ms558 MB
GOGC=200793 ms90,8 ms813 MB
GOGC=400936 ms50,6 ms1.275 MB
GOGC=8001.030 ms30,3 ms2.181 MB
GOGC=off, GOMEMLIMIT=300MiB1.351 ms635,9 ms330 MB

O que isso mostra:

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.

9. Qual ferramenta para qual pergunta

PerguntaFerramenta
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

11. O que mencionar em uma entrevista

Resumo rápido

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

Pratique este tema: Go

Mais guias