Noções Básicas de Concorrência

10 exemplos para você começar com Concorrência - 7 básicos e 3 intermediários.

Pré-requisitos

• Instale Go 1.26.x ou posterior em go.dev/dl.
• Crie um módulo: mkdir conc && cd conc && go mod init example.com/conc.
• Salve cada snippet como main.go e execute com go run ..
• Execute go test -race ./... quando os exemplos usarem estado compartilhado.

Exemplos Básicos

1. Iniciar uma goroutine

Comece o trabalho concorrentemente com go.

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    go func() {
        fmt.Println("da goroutine")
    }()
    time.Sleep(100 * time.Millisecond) // espera para que a saída apareça antes de sair
    fmt.Println("da main")
}

• go agenda a função em uma nova goroutine; ela retorna imediatamente.
• Sem uma espera, main pode sair antes que a goroutine imprima.
• Prefira sync.WaitGroup ou canais em vez de time.Sleep em código real.

Relacionado: Concorrência em Go: Goroutines e Canais Primeiro - Modelo mental CSP

2. Handoff de canal não bufferizado

Remetente e receptor se encontram no canal.

package main
 
import "fmt"
 
func main() {
    ch := make(chan string)
    go func() { ch <- "ping" }()
    msg := <-ch
    fmt.Println(msg)
}

• make(chan string) cria um canal não bufferizado - capacidade zero.
• O envio bloqueia até que o recebimento esteja pronto; esse é o ponto de sincronização.
• O valor é passado por cópia (para tipos pequenos); structs grandes podem usar ponteiros.

Relacionado: Canais: Regras de Buffer, Não Buffer e Fechamento - regras de buffer e fechamento

3. Canal bufferizado

Desacople remetente e receptor até a capacidade.

package main
 
import "fmt"
 
func main() {
    ch := make(chan int, 2)
    ch <- 1
    ch <- 2
    fmt.Println(<-ch, <-ch)
}

• make(chan int, 2) permite dois envios sem um receptor esperando.
• O terceiro envio bloquearia até que alguém recebesse.
• Dimensionar buffers para o burst natural do seu pipeline, não arbitrariamente grandes.

Relacionado: Canais: Regras de Buffer, Não Buffer e Fechamento - quando usar buffer

4. sync.WaitGroup

Espere um lote de goroutines terminar.

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go func(n int) {
            defer wg.Done()
            fmt.Println("worker", n)
        }(i)
    }
    wg.Wait()
    fmt.Println("done")
}

• Add antes de go, Done em um defer dentro do worker.
• Wait bloqueia até que o contador retorne a zero.
• Passe variáveis de loop como parâmetros para evitar bugs de captura de closure em padrões mais antigos.

Relacionado: sync.Mutex, RWMutex e WaitGroup - detalhes do WaitGroup

5. Fechar e iterar sobre um canal

Sinalize a conclusão fechando do remetente.

package main
 
import "fmt"
 
func main() {
    ch := make(chan int, 3)
    ch <- 1
    ch <- 2
    ch <- 3
    close(ch)
    for v := range ch {
        fmt.Println(v)
    }
}

• range esvazia até que o canal seja fechado e vazio.
• Apenas o remetente deve close; enviar em um canal fechado causa pânico.
• Receber após o fechamento retorna valores zero com ok == false na forma de dois valores.

Relacionado: Canais: Regras de Buffer, Não Buffer e Fechamento - regras de propriedade

6. select com um caso

select espera por operações de canal (aqui, um único recebimento).

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    ch := make(chan string)
    go func() {
        time.Sleep(50 * time.Millisecond)
        ch <- "ready"
    }()
    select {
    case msg := <-ch:
        fmt.Println(msg)
    }
}

• select bloqueia até que um caso possa prosseguir.
• Com um caso, ele se comporta como um recebimento, mas se prepara para adicionar timeouts.
• Adicione um branch default para comportamento não bloqueante.

Relacionado: Instrução select e Casos Padrão - padrões de multiplexação

7. Mutex protegendo estado compartilhado

Quando múltiplas goroutines mutam dados, bloqueie-os.

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    var mu sync.Mutex
    count := 0
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            mu.Lock()
            count++
            mu.Unlock()
        }()
    }
    wg.Wait()
    fmt.Println(count)
}

• Mutex serializa seções críticas - aqui count++.
• Sempre emparelhe Lock com Unlock; defer mu.Unlock() após Lock é idiomático.
• Execute com -race para capturar locks ausentes.

Relacionado: sync.Mutex, RWMutex e WaitGroup - disciplina de lock

Exemplos Intermediários

8. select com timeout

Evite esperar para sempre por trabalho lento.

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    ch := make(chan string)
    select {
    case msg := <-ch:
        fmt.Println(msg)
    case <-time.After(100 * time.Millisecond):
        fmt.Println("timeout")
    }
}

• time.After retorna um canal que dispara após a duração.
• O caso que estiver pronto primeiro vence; aqui nada envia, então o timeout é impresso.
• Em servidores, vincule timeouts a prazos de context.Context em vez de sleeps ad-hoc.

Relacionado: Instrução select e Casos Padrão - receitas de timeout

9. Pipeline Fan-out simples

Um produtor, uma goroutine consumidora.

package main
 
import "fmt"
 
func main() {
    jobs := make(chan int, 5)
    done := make(chan struct{})
 
    go func() {
        for j := range jobs {
            fmt.Println("processado", j)
        }
        close(done)
    }()
 
    for i := 1; i <= 3; i++ {
        jobs <- i
    }
    close(jobs)
    <-done
}

• Fechar jobs permite que o worker range saia limpo.
• done sinaliza que o consumidor terminou - alternativa ao WaitGroup.
• Pipelines escalam adicionando estágios e buffers limitados entre eles.

Relacionado: Goroutines: Custo de Criação e Visão Geral do Agendamento - agendando muitos workers

10. Detectar corridas em testes

Compile com -race para capturar acesso não sincronizado.

package main
 
import (
    "sync"
    "testing"
)
 
func TestCounter(t *testing.T) {
    var wg sync.WaitGroup
    n := 0
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            n++ // corrida: descomente mu do exemplo 7 para corrigir
        }()
    }
    wg.Wait()
}

• Execute go test -race - o detector de corrida relata acessos conflitantes.
• Corrija com mutex, atômico ou handoff de canal - não ignorando relatórios.
• Habilite -race em CI para pacotes que usam goroutines.

Relacionado: Detector de Corridas: Executando e Interpretando Saída - lendo a saída de corrida

Versões de Stack: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, modernizadores go fix - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação). WTI5a1pXZDFhV1JsY3k1cGIzeGpaMmx2TkRBMWZESXdNall3Tnc9PQ==