0Pricing
Go Academy · Aula

Canais com buffer

Capacidade, fechamento de canais e uso de range sobre canais

Canais com buffer é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

O que é um canal com buffer?

Um canal com buffer tem uma capacidade — os envios não ficam bloqueados enquanto houver espaço no buffer. O canal funciona como uma fila:

package main
import "fmt"

func main() {
    ch := make(chan int, 3)  // capacity 3

    ch <- 1  // does not block — buffer has room
    ch <- 2  // does not block
    ch <- 3  // does not block
    // ch <- 4  // would block — buffer full

    fmt.Println(<-ch) // 1
    fmt.Println(<-ch) // 2
    fmt.Println(<-ch) // 3
}

Canal com buffer como fila

Canais com buffer implementam uma fila FIFO entre goroutines:

package main
import ("fmt"; "sync")

func producer(ch chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := 1; i <= 5; i++ {
        ch <- i
        fmt.Printf("produced %d\n", i)
    }
}

func main() {
    ch := make(chan int, 2)  // buffer 2 — producer runs ahead
    var wg sync.WaitGroup
    wg.Add(1)
    go producer(ch, &wg)
    wg.Wait()
    close(ch)
    for v := range ch { fmt.Printf("consumed %d\n", v) }
}

len() e cap() em canais

Verifique o tamanho atual e a capacidade de um canal com buffer:

package main
import "fmt"

func main() {
    ch := make(chan string, 5)
    ch <- "a"
    ch <- "b"
    ch <- "c"

    fmt.Println("cap:", cap(ch))  // 5
    fmt.Println("len:", len(ch))  // 3 — items currently buffered

    <-ch
    fmt.Println("len:", len(ch))  // 2
}

Desacoplando producer e consumer

Um buffer desacopla a velocidade do producer da velocidade do consumer. O producer pode adiantar-se pelo tamanho do buffer antes de ficar bloqueado:

package main
import ("fmt"; "sync"; "time")

func produce(ch chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := 0; i < 5; i++ {
        ch <- i
    }
}

func consume(ch <-chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for v := range ch {
        time.Sleep(10 * time.Millisecond)  // slower consumer
        fmt.Println("consumed:", v)
    }
}

func main() {
    ch := make(chan int, 3)
    var wg sync.WaitGroup
    wg.Add(2)
    go produce(ch, &wg)
    go consume(ch, &wg) // BUG: produce closes before consume sees all
    // In practice, coordinate close carefully
    fmt.Println("decoupled")
}

Semáforo com canal com buffer

Um canal com buffer de capacidade N pode limitar a N o número de goroutines concorrentes — um semáforo simples:

package main
import ("fmt"; "sync"; "time")

func main() {
    sem := make(chan struct{}, 3)  // max 3 concurrent
    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {
        wg.Add(1)
        i := i
        go func() {
            defer wg.Done()
            sem <- struct{}{}    // acquire
            defer func() { <-sem }()  // release
            fmt.Printf("job %d running\n", i)
            time.Sleep(50 * time.Millisecond)
        }()
    }
    wg.Wait()
}

Fechando um canal com buffer

Fechar um canal com buffer permite que receivers consumam os valores restantes do buffer antes de detectar o fechamento:

package main
import "fmt"

func main() {
    ch := make(chan int, 5)
    for i := 1; i <= 3; i++ { ch <- i }
    close(ch)

    // Drain all buffered values after close:
    for v := range ch {
        fmt.Println(v)  // 1, 2, 3
    }
    // range exits after channel closed and drained
}

Com buffer versus sem buffer: quando escolher

Guia de decisão:

  • Sem buffer: transferência síncrona garantida, ordenação estrita, sincronização por encontro
  • Com buffer: desacopla as velocidades do producer e do consumer, reduz bloqueios, implementa semáforos, coleta N resultados
  • Use canais sem buffer por padrão — adicione um buffer somente quando puder justificar o tamanho
  • Um buffer pequeno demais → ainda causa bloqueios; grande demais → esconde erros

Coletando resultados com um canal com buffer

Use um canal com buffer para coletar resultados de goroutines paralelas sem bloqueá-las:

package main
import ("fmt"; "sync")

func square(n int) int { return n * n }

func main() {
    nums := []int{1, 2, 3, 4, 5}
    results := make(chan int, len(nums))  // buffer = goroutine count
    var wg sync.WaitGroup

    for _, n := range nums {
        wg.Add(1)
        n := n
        go func() {
            defer wg.Done()
            results <- square(n)
        }()
    }
    wg.Wait()
    close(results)

    for r := range results { fmt.Println(r) }
}

Vazamento de goroutine com buffer cheio

Se o buffer estiver cheio e não houver um leitor, o sender ficará bloqueado para sempre — um vazamento de goroutine:

package main
import ("fmt"; "time"; "runtime")

func main() {
    ch := make(chan int, 2)
    // Start goroutine that fills buffer and then blocks
    go func() {
        ch <- 1
        ch <- 2
        ch <- 3  // blocks: buffer full, no receiver
        fmt.Println("never reached")
    }()
    time.Sleep(50 * time.Millisecond)
    fmt.Println("goroutines:", runtime.NumGoroutine()) // 2 — leaked
}

time.After como canal com buffer

time.After retorna um <-chan time.Time com buffer de capacidade 1. O ambiente de execução envia um valor para ele após a duração e, em seguida, ele é coletado pelo coletor de lixo:

package main
import ("fmt"; "time")

func doWithTimeout(work func() string) (string, bool) {
    result := make(chan string, 1)
    go func() { result <- work() }()
    select {
    case r := <-result:
        return r, true
    case <-time.After(100 * time.Millisecond):
        return "", false
    }
}

func main() {
    r, ok := doWithTimeout(func() string {
        time.Sleep(50 * time.Millisecond)
        return "done"
    })
    fmt.Println(r, ok)
}

Verificação rápida

O que acontece quando se envia para um canal com buffer que está na capacidade máxima?

Revisão: canais com buffer

Resumo:

  • make(chan T, N) cria um canal com buffer de capacidade N
  • Os envios ficam bloqueados somente quando o buffer está cheio; os recebimentos ficam bloqueados somente quando ele está vazio
  • len(ch) — itens atuais; cap(ch) — capacidade
  • Use-os para desacoplar producers e consumers, coletar resultados paralelos e implementar semáforos
  • Fechar permite o esvaziamento antes de EOF; range ch gerencia isso automaticamente

Perguntas Frequentes

A aula “Canais com buffer” é grátis?

Sim — o texto completo de “Canais com buffer” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Canais com buffer”?

Capacidade, fechamento de canais e uso de range sobre canais Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Canais com buffer”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Iniciando goroutines
  2. Canais sem buffer
  3. Canais com buffer
  4. Direção de canais e padrões de pipeline
← Voltar para Go Academy