Noções Básicas de Concorrência Avançada

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

Pré-requisitos

Go 1.26.x ou posterior e um módulo: go mod init example.com/advconc.
Instale extensões: go get golang.org/x/sync/errgroup golang.org/x/time/rate.
Execute exemplos com go run . a partir do diretório de pacote de cada trecho.
Familiaridade com goroutines e canais de Noções Básicas de Concorrência ajuda.

Exemplos Básicos

1. Pool de workers fixo com canal de jobs

Inicie N workers que leem jobs até que o canal seja fechado.

package main
 
import (
    "fmt"
    "sync"
)
 
func worker(id int, jobs <-chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for j := range jobs {
        fmt.Printf("worker %d job %d\n", id, j)
    }
}
 
func main() {
    const workers = 3
    jobs := make(chan int, 10)
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go worker(i, jobs, &wg)
    }
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)
    wg.Wait()
}

close(jobs) sinaliza aos workers para saírem após esvaziar.
O tamanho do buffer desacopla os produtores brevemente; buffer zero sincroniza cada envio.
WaitGroup espera pelos workers antes que main retorne.

Relacionado: Pools de Workers e Filas de Tarefas - dimensionamento e padrões de desligamento

2. Semáforo com canal com buffer

Limite goroutines em execução sem um conjunto de workers dedicado.

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    sem := make(chan struct{}, 2) // max 2 concorrentes
    var wg sync.WaitGroup
    for i := 0; i < 6; i++ {
        wg.Add(1)
        go func(n int) {
            defer wg.Done()
            sem <- struct{}{}
            defer func() { <-sem }()
            fmt.Println("task", n)
        }(i)
    }
    wg.Wait()
}

Enviar adquire um slot; receber o libera.
A capacidade é igual ao paralelismo máximo - um semáforo de contagem idiomático.
Prefira golang.org/x/sync/semaphore quando precisar de Acquire(ctx) com cancelamento.

Relacionado: Limitação de Taxa e Backpressure - baldes de tokens e descarte

3. errgroup com tarefas paralelas

Execute goroutines relacionadas; o primeiro erro cancela as demais.

package main
 
import (
    "context"
    "fmt"
    "time"
 
    "golang.org/x/sync/errgroup"
)
 
func main() {
    g, ctx := errgroup.WithContext(context.Background())
    g.Go(func() error {
        return fmt.Errorf("task a failed")
    })
    g.Go(func() error {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case <-time.After(time.Second):
            return nil
        }
    })
    if err := g.Wait(); err != nil {
        fmt.Println("errgroup:", err)
    }
}

WithContext cancela ctx quando qualquer Go retorna um erro não nulo.
Sempre respeite ctx em funções Go de longa execução.
Wait bloqueia até que todas as goroutines terminem e retorna o primeiro erro.

Relacionado: errgroup e Extensões golang.org/x/sync - SetLimit e padrões

4. Pipeline de dois estágios

Uma goroutine produz, outra consome através de um canal.

package main
 
import (
    "fmt"
)
 
func main() {
    out := make(chan int)
    go func() {
        defer close(out)
        for i := 1; i <= 3; i++ {
            out <- i * 10
        }
    }()
    for v := range out {
        fmt.Println(v)
    }
}

O produtor é o dono do canal e deve fechá-lo quando terminar.
range sobre o canal recebe até o fechamento.
Adicione buffer entre os estágios para reduzir o bloqueio quando as taxas diferem.

Relacionado: Fan-In, Fan-Out e Estágios de Pipeline - grafos multiestágios

5. Fan-out com WaitGroup

Distribua itens para workers, espere a conclusão.

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    items := []int{1, 2, 3, 4}
    var wg sync.WaitGroup
    for _, item := range items {
        wg.Add(1)
        go func(v int) {
            defer wg.Done()
            fmt.Println("process", v)
        }(item)
    }
    wg.Wait()
}

Capture a variável de loop no parâmetro de closure para evitar o bug clássico da variável de loop.
Fan-out ilimitado é aceitável para N pequeno; use um pool para lotes grandes.
Erros precisam de uma estratégia de agregação separada (errgroup ou canal de erro).

Relacionado: Concorrência em Produção: Padrões Além do Hello Goroutine - quando limitar o fan-out

6. Loop de worker cancelado por contexto

Pare os workers quando o contexto for concluído.

package main
 
import (
    "context"
    "fmt"
    "time"
)
 
func worker(ctx context.Context, id int) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("worker", id, "stop")
            return
        default:
            fmt.Println("worker", id, "tick")
            time.Sleep(200 * time.Millisecond)
        }
    }
}
 
func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
    defer cancel()
    go worker(ctx, 1)
    <-ctx.Done()
    time.Sleep(100 * time.Millisecond)
}

select em ctx.Done() é obrigatório em loops de produção.
WithTimeout deriva um prazo do contexto pai.
Emparelhe com WaitGroup quando múltiplos workers precisarem sair antes de prosseguir.

Relacionado: Noções Básicas de Contexto - WithCancel e prazos

7. Incremento de contador atômico

Contador sem bloqueio para métricas e IDs.

package main
 
import (
    "fmt"
    "sync"
    "sync/atomic"
)
 
func main() {
    var n atomic.Int64
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            n.Add(1)
        }()
    }
    wg.Wait()
    fmt.Println("count", n.Load())
}

atomic.Int64 é tipado e mais claro do que int64 bruto com AddInt64.
Use atômicos para contadores simples; use mutex para structs com múltiplos campos.
Execute go test -race se você misturar atômicos com leituras não atômicas.

Relacionado: Operações sync/atomic - CAS e quando os atômicos vencem

Exemplos Intermediários

8. Pool de workers com desligamento por contexto

Parada graciosa: cancela o contexto, fecha os jobs, espera pelos workers.

package main
 
import (
    "context"
    "fmt"
    "sync"
    "time"
)
 
func pool(ctx context.Context, jobs <-chan int, n int) *sync.WaitGroup {
    var wg sync.WaitGroup
    for i := 0; i < n; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for {
                select {
                case <-ctx.Done():
                    return
                case j, ok := <-jobs:
                    if !ok {
                        return
                    }
                    fmt.Println(id, "handled", j)
                }
            }
        }(i)
    }
    return &wg
}
 
func main() {
    ctx, cancel := context.WithCancel(context.Background())
    jobs := make(chan int, 4)
    wg := pool(ctx, jobs, 2)
    for j := 1; j <= 4; j++ {
        jobs <- j
    }
    close(jobs)
    cancel()
    wg.Wait()
}

ctx.Done() combinado com !ok nos jobs cobre os caminhos de cancelamento e esvaziamento.
Feche o canal de jobs somente após os produtores terminarem de enviar.
wg.Wait() antes de sair confirma que os workers pararam.

Relacionado: Evitando Vazamentos de Goroutine e Deadlocks de Canal - regras de propriedade

9. errgroup para buscas paralelas estilo HTTP

Simule I/O paralelo com cancelamento compartilhado no primeiro erro.

package main
 
import (
    "context"
    "errors"
    "fmt"
 
    "golang.org/x/sync/errgroup"
)
 
func fetch(ctx context.Context, name string, fail bool) error {
    if fail {
        return fmt.Errorf("%s unavailable", name)
    }
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
        fmt.Println("ok", name)
        return nil
    }
}
 
func main() {
    g, ctx := errgroup.WithContext(context.Background())
    g.Go(func() error { return fetch(ctx, "users", false) })
    g.Go(func() error { return fetch(ctx, "billing", true) })
    if err := g.Wait(); err != nil {
        fmt.Println("abort:", err)
    }
}

A primeira busca falha cancela ctx para os irmãos ainda em execução.
Mapeie este padrão para http.NewRequestWithContext em serviços reais.
Use g.SetLimit(n) quando o fan-out deve respeitar cotas downstream.

Relacionado: Propagação de Cancelamento em Handlers HTTP - ctx com escopo de requisição

10. Produtor com taxa limitada

O balde de tokens limita a velocidade com que os jobs entram no pool.

package main
 
import (
    "context"
    "fmt"
    "time"
 
    "golang.org/x/time/rate"
)
 
func main() {
    lim := rate.NewLimiter(rate.Every(100*time.Millisecond), 1)
    ctx := context.Background()
    for i := 1; i <= 5; i++ {
        if err := lim.Wait(ctx); err != nil {
            panic(err)
        }
        fmt.Println("emit", i, time.Now().Format("15:04:05.000"))
    }
}

Every(d) define a taxa constante; o burst permite picos curtos.
Wait bloqueia; Allow não bloqueia para caminhos de descarte de carga.
Passe o ctx da requisição em Wait para que o cancelamento pare um produtor limitado.

Relacionado: Limitação de Taxa e Backpressure - semáforos vs balde de tokens

Versões da Stack: Esta página foi escrita para Go 1.26.x (padrão GC Green Tea, go fix modernizers - 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).

Pré-requisitos

Go 1.26.x ou posterior e um módulo: go mod init example.com/advconc.
Instale extensões: go get golang.org/x/sync/errgroup golang.org/x/time/rate.
Execute exemplos com go run . a partir do diretório de pacote de cada trecho.
Familiaridade com goroutines e canais de Noções Básicas de Concorrência ajuda.

Exemplos Básicos

1. Pool de workers fixo com canal de jobs

Inicie N workers que leem jobs até que o canal seja fechado.

package main
 
import (
    "fmt"
    "sync"
)
 
func worker(id int, jobs <-chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for j := range jobs {
        fmt.Printf("worker %d job %d\n", id, j)
    }
}
 
func main() {
    const workers = 3
    jobs := make(chan int, 10)
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go worker(i, jobs, &wg)
    }
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)
    wg.Wait()
}

close(jobs) sinaliza aos workers para saírem após esvaziar.
O tamanho do buffer desacopla os produtores brevemente; buffer zero sincroniza cada envio.
WaitGroup espera pelos workers antes que main retorne.

Relacionado: Pools de Workers e Filas de Tarefas - dimensionamento e padrões de desligamento

2. Semáforo com canal com buffer

Limite goroutines em execução sem um conjunto de workers dedicado.

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    sem := make(chan struct{}, 2) // max 2 concorrentes
    var wg sync.WaitGroup
    for i := 0; i < 6; i++ {
        wg.Add(1)
        go func(n int) {
            defer wg.Done()
            sem <- struct{}{}
            defer func() { <-sem }()
            fmt.Println("task", n)
        }(i)
    }
    wg.Wait()
}

Enviar adquire um slot; receber o libera.
A capacidade é igual ao paralelismo máximo - um semáforo de contagem idiomático.
Prefira golang.org/x/sync/semaphore quando precisar de Acquire(ctx) com cancelamento.

Relacionado: Limitação de Taxa e Backpressure - baldes de tokens e descarte

3. errgroup com tarefas paralelas

Execute goroutines relacionadas; o primeiro erro cancela as demais.

package main
 
import (
    "context"
    "fmt"
    "time"
 
    "golang.org/x/sync/errgroup"
)
 
func main() {
    g, ctx := errgroup.WithContext(context.Background())
    g.Go(func() error {
        return fmt.Errorf("task a failed")
    })
    g.Go(func() error {
        select {
        case <-ctx.Done():
            return ctx.Err()
        case <-time.After(time.Second):
            return nil
        }
    })
    if err := g.Wait(); err != nil {
        fmt.Println("errgroup:", err)
    }
}

WithContext cancela ctx quando qualquer Go retorna um erro não nulo.
Sempre respeite ctx em funções Go de longa execução.
Wait bloqueia até que todas as goroutines terminem e retorna o primeiro erro.

Relacionado: errgroup e Extensões golang.org/x/sync - SetLimit e padrões

4. Pipeline de dois estágios

Uma goroutine produz, outra consome através de um canal.

package main
 
import (
    "fmt"
)
 
func main() {
    out := make(chan int)
    go func() {
        defer close(out)
        for i := 1; i <= 3; i++ {
            out <- i * 10
        }
    }()
    for v := range out {
        fmt.Println(v)
    }
}

O produtor é o dono do canal e deve fechá-lo quando terminar.
range sobre o canal recebe até o fechamento.
Adicione buffer entre os estágios para reduzir o bloqueio quando as taxas diferem.

Relacionado: Fan-In, Fan-Out e Estágios de Pipeline - grafos multiestágios

5. Fan-out com WaitGroup

Distribua itens para workers, espere a conclusão.

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
    items := []int{1, 2, 3, 4}
    var wg sync.WaitGroup
    for _, item := range items {
        wg.Add(1)
        go func(v int) {
            defer wg.Done()
            fmt.Println("process", v)
        }(item)
    }
    wg.Wait()
}

Capture a variável de loop no parâmetro de closure para evitar o bug clássico da variável de loop.
Fan-out ilimitado é aceitável para N pequeno; use um pool para lotes grandes.
Erros precisam de uma estratégia de agregação separada (errgroup ou canal de erro).

Relacionado: Concorrência em Produção: Padrões Além do Hello Goroutine - quando limitar o fan-out

6. Loop de worker cancelado por contexto

Pare os workers quando o contexto for concluído.

package main
 
import (
    "context"
    "fmt"
    "time"
)
 
func worker(ctx context.Context, id int) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("worker", id, "stop")
            return
        default:
            fmt.Println("worker", id, "tick")
            time.Sleep(200 * time.Millisecond)
        }
    }
}
 
func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
    defer cancel()
    go worker(ctx, 1)
    <-ctx.Done()
    time.Sleep(100 * time.Millisecond)
}

select em ctx.Done() é obrigatório em loops de produção.
WithTimeout deriva um prazo do contexto pai.
Emparelhe com WaitGroup quando múltiplos workers precisarem sair antes de prosseguir.

Relacionado: Noções Básicas de Contexto - WithCancel e prazos

7. Incremento de contador atômico

Contador sem bloqueio para métricas e IDs.

package main
 
import (
    "fmt"
    "sync"
    "sync/atomic"
)
 
func main() {
    var n atomic.Int64
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            n.Add(1)
        }()
    }
    wg.Wait()
    fmt.Println("count", n.Load())
}

atomic.Int64 é tipado e mais claro do que int64 bruto com AddInt64.
Use atômicos para contadores simples; use mutex para structs com múltiplos campos.
Execute go test -race se você misturar atômicos com leituras não atômicas.

Relacionado: Operações sync/atomic - CAS e quando os atômicos vencem

Exemplos Intermediários

8. Pool de workers com desligamento por contexto

Parada graciosa: cancela o contexto, fecha os jobs, espera pelos workers.

package main
 
import (
    "context"
    "fmt"
    "sync"
    "time"
)
 
func pool(ctx context.Context, jobs <-chan int, n int) *sync.WaitGroup {
    var wg sync.WaitGroup
    for i := 0; i < n; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for {
                select {
                case <-ctx.Done():
                    return
                case j, ok := <-jobs:
                    if !ok {
                        return
                    }
                    fmt.Println(id, "handled", j)
                }
            }
        }(i)
    }
    return &wg
}
 
func main() {
    ctx, cancel := context.WithCancel(context.Background())
    jobs := make(chan int, 4)
    wg := pool(ctx, jobs, 2)
    for j := 1; j <= 4; j++ {
        jobs <- j
    }
    close(jobs)
    cancel()
    wg.Wait()
}

ctx.Done() combinado com !ok nos jobs cobre os caminhos de cancelamento e esvaziamento.
Feche o canal de jobs somente após os produtores terminarem de enviar.
wg.Wait() antes de sair confirma que os workers pararam.

Relacionado: Evitando Vazamentos de Goroutine e Deadlocks de Canal - regras de propriedade

9. errgroup para buscas paralelas estilo HTTP

Simule I/O paralelo com cancelamento compartilhado no primeiro erro.

package main
 
import (
    "context"
    "errors"
    "fmt"
 
    "golang.org/x/sync/errgroup"
)
 
func fetch(ctx context.Context, name string, fail bool) error {
    if fail {
        return fmt.Errorf("%s unavailable", name)
    }
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
        fmt.Println("ok", name)
        return nil
    }
}
 
func main() {
    g, ctx := errgroup.WithContext(context.Background())
    g.Go(func() error { return fetch(ctx, "users", false) })
    g.Go(func() error { return fetch(ctx, "billing", true) })
    if err := g.Wait(); err != nil {
        fmt.Println("abort:", err)
    }
}

A primeira busca falha cancela ctx para os irmãos ainda em execução.
Mapeie este padrão para http.NewRequestWithContext em serviços reais.
Use g.SetLimit(n) quando o fan-out deve respeitar cotas downstream.

Relacionado: Propagação de Cancelamento em Handlers HTTP - ctx com escopo de requisição

10. Produtor com taxa limitada

O balde de tokens limita a velocidade com que os jobs entram no pool.

package main
 
import (
    "context"
    "fmt"
    "time"
 
    "golang.org/x/time/rate"
)
 
func main() {
    lim := rate.NewLimiter(rate.Every(100*time.Millisecond), 1)
    ctx := context.Background()
    for i := 1; i <= 5; i++ {
        if err := lim.Wait(ctx); err != nil {
            panic(err)
        }
        fmt.Println("emit", i, time.Now().Format("15:04:05.000"))
    }
}

Every(d) define a taxa constante; o burst permite picos curtos.
Wait bloqueia; Allow não bloqueia para caminhos de descarte de carga.
Passe o ctx da requisição em Wait para que o cancelamento pare um produtor limitado.

Relacionado: Limitação de Taxa e Backpressure - semáforos vs balde de tokens

Versões da Stack: Esta página foi escrita para Go 1.26.x (padrão GC Green Tea, go fix modernizers - 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).

Noções Básicas de Concorrência Avançada

Buscar na documentação

Noções Básicas de Concorrência Avançada