Goroutines e channels: concurrency model

⏱ 14 min·⭐ 60 XP

Pré-requisitos (0/1)0%

⬜🎯 Go mental model: simplicity first(Go Profissional)

Recomendamos completar os pré-requisitos antes de seguir, mas nada te impede de continuar.

Goroutine: thread barata do Go

Goroutine nasce com ~2 KB de stack e cresce sob demanda. O runtime Go escala M goroutines em N threads do SO (modelo M:N). Um processo Go segura milhões de goroutines em RAM moderada — esse é o superpoder do modelo.

Channels em três sabores

// Unbuffered: rendezvous
ch := make(chan int)
go func() { ch <- 42 }()   // bloqueia até alguém receber
v := <-ch                  // desbloqueia o sender

// Buffered: fila com capacidade
jobs := make(chan Job, 100)
jobs <- j                   // não bloqueia até encher

// Channel direcional em assinatura (melhora API)
func producer(out chan<- int) { out <- 1 }
func consumer(in <-chan int)  { v := <-in; _ = v }

select: o heart do Go concorrente

func fetchWithTimeout(ctx context.Context, url string) (string, error) {
    result := make(chan string, 1)
    errCh  := make(chan error, 1)

    go func() {
        body, err := doFetch(url)
        if err != nil {
            errCh <- err
            return
        }
        result <- body
    }()

    select {
    case body := <-result:
        return body, nil
    case err := <-errCh:
        return "", err
    case <-ctx.Done():
        return "", ctx.Err()
    }
}

💡

Esse é o padrão canônico: goroutine worker escreve em channel buffered 1 (evita leak se ninguém ler), select aguarda primeiro evento, ctx.Done oferece cancelamento cooperativo.

Fan-out / fan-in

func fanOutFanIn(urls []string) []Result {
    jobs    := make(chan string, len(urls))
    results := make(chan Result, len(urls))

    const workers = 8
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for u := range jobs {
                results <- fetch(u)
            }
        }()
    }
    for _, u := range urls { jobs <- u }
    close(jobs)

    go func() { wg.Wait(); close(results) }()

    out := make([]Result, 0, len(urls))
    for r := range results { out = append(out, r) }
    return out
}

Distribuir trabalho e recolher resultado sem compartilhar memória

Origem

Produtorenvia trabalho no canal

Canal de trabalhosfecha quando não há mais

Trabalhadores

Trabalhador 1

Trabalhador 2

Trabalhador No número é seu — não é automático

Recolhimento

Canal de resultados

Contador de conclusãoquem fecha o canal de resultados, e só depois de todos terminarem

Cancelamento

Contextotodo trabalhador precisa observá-lo

→ fecha quando zera

Compute
Integração de apps
Conceito de arquitetura
Segurança e identidade

O lema da linguagem — comunicar em vez de compartilhar — está desenhado aqui: nenhuma trava, nenhuma memória compartilhada, só canais. O que sobra de complexidade é encerramento e cancelamento, e são exatamente esses dois pontos que os defeitos exploram.

Quiz rápido

Qual é o modelo de concorrência que a linguagem incentiva?

Armadilhas comuns

⚠️

1) goroutine que nunca retorna = leak (cada URL acima poderia vazar se alguém não fechasse jobs). 2) Escrever em channel fechado = panic. 3) Ler de channel nil = bloqueia para sempre. 4) range sobre channel só termina com close. Disciplina de lifecycle é meio caminho.

Race detector em CI

go test -race -count=1 ./...
# 2-10x mais lento, mas captura corridas escondidas
# rode sempre em PR, é o teste mais barato contra bug intermitente

✅

Regra prática: se o teste passa sem -race e falha com -race, você tem bug real. Corrija com mutex, channel ou atomic — nunca ignore.

Perguntas frequentes

❓ O que é uma rotina leve e por que ela é barata?

É uma unidade de execução gerenciada pelo próprio tempo de execução da linguagem, com pilha inicial de poucos kilobytes que cresce sob demanda — daí ser viável ter centenas de milhares. O escalonador as multiplexa sobre linhas de execução do sistema.

❓ Canal ou mutex: qual usar em Go?

Canal quando a comunicação é o problema — passar dado entre rotinas, coordenar etapas. Mutex quando é proteção de estado compartilhado. Usar canal para proteger estado gera código mais complicado que o mutex equivalente, e é o excesso mais comum de quem aprendeu a linguagem pelo slogan.

❓ O que causa vazamento de rotina?

Rotina bloqueada para sempre em canal sem leitor ou sem cancelamento. Ela não é coletada e acumula. É por isso que toda rotina lançada precisa de caminho de término — e o mecanismo canônico para isso é o contexto de cancelamento.

Fixando

Quiz rápido

Qual é o erro mais comum ao usar rotinas leves?

Quiz rápido

Para que serve o contexto propagado entre chamadas?

Terminou de ler?

Marcar como concluído registra o XP, mantém sua sequência e coloca 3 cartas deste módulo na fila de revisão espaçada.

Próximos passos sugeridos

⏱️

Context package: cancellation, timeout, values

Go Profissional · 13 min · +55 XP

→

Temas deste módulo

Linguagens

Discussão

Carregando comentários…

Goroutines e channels: concurrency model

⏱ 14 min·⭐ 60 XP

Pré-requisitos (0/1)0%

⬜🎯 Go mental model: simplicity first(Go Profissional)

Recomendamos completar os pré-requisitos antes de seguir, mas nada te impede de continuar.

Goroutine: thread barata do Go

Channels em três sabores

// Unbuffered: rendezvous
ch := make(chan int)
go func() { ch <- 42 }()   // bloqueia até alguém receber
v := <-ch                  // desbloqueia o sender

// Buffered: fila com capacidade
jobs := make(chan Job, 100)
jobs <- j                   // não bloqueia até encher

// Channel direcional em assinatura (melhora API)
func producer(out chan<- int) { out <- 1 }
func consumer(in <-chan int)  { v := <-in; _ = v }

select: o heart do Go concorrente

func fetchWithTimeout(ctx context.Context, url string) (string, error) {
    result := make(chan string, 1)
    errCh  := make(chan error, 1)

    go func() {
        body, err := doFetch(url)
        if err != nil {
            errCh <- err
            return
        }
        result <- body
    }()

    select {
    case body := <-result:
        return body, nil
    case err := <-errCh:
        return "", err
    case <-ctx.Done():
        return "", ctx.Err()
    }
}

💡

Esse é o padrão canônico: goroutine worker escreve em channel buffered 1 (evita leak se ninguém ler), select aguarda primeiro evento, ctx.Done oferece cancelamento cooperativo.

Fan-out / fan-in

func fanOutFanIn(urls []string) []Result {
    jobs    := make(chan string, len(urls))
    results := make(chan Result, len(urls))

    const workers = 8
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for u := range jobs {
                results <- fetch(u)
            }
        }()
    }
    for _, u := range urls { jobs <- u }
    close(jobs)

    go func() { wg.Wait(); close(results) }()

    out := make([]Result, 0, len(urls))
    for r := range results { out = append(out, r) }
    return out
}

Distribuir trabalho e recolher resultado sem compartilhar memória

Origem

Produtorenvia trabalho no canal

Canal de trabalhosfecha quando não há mais

Trabalhadores

Trabalhador 1

Trabalhador 2

Trabalhador No número é seu — não é automático

Recolhimento

Canal de resultados

Contador de conclusãoquem fecha o canal de resultados, e só depois de todos terminarem

Cancelamento

Contextotodo trabalhador precisa observá-lo

→ fecha quando zera

Compute
Integração de apps
Conceito de arquitetura
Segurança e identidade

Quiz rápido

Qual é o modelo de concorrência que a linguagem incentiva?

Armadilhas comuns

⚠️

Race detector em CI

go test -race -count=1 ./...
# 2-10x mais lento, mas captura corridas escondidas
# rode sempre em PR, é o teste mais barato contra bug intermitente

✅

Regra prática: se o teste passa sem -race e falha com -race, você tem bug real. Corrija com mutex, channel ou atomic — nunca ignore.

Perguntas frequentes

❓ O que é uma rotina leve e por que ela é barata?

❓ Canal ou mutex: qual usar em Go?

❓ O que causa vazamento de rotina?

Fixando

Quiz rápido

Qual é o erro mais comum ao usar rotinas leves?

Quiz rápido

Para que serve o contexto propagado entre chamadas?

Terminou de ler?

Marcar como concluído registra o XP, mantém sua sequência e coloca 3 cartas deste módulo na fila de revisão espaçada.

Próximos passos sugeridos

⏱️

Context package: cancellation, timeout, values

Go Profissional · 13 min · +55 XP

→

Temas deste módulo

Linguagens

Discussão

Carregando comentários…