Concorrência em Go: Goroutines e Channels
Aprenda concorrência em Go: goroutines (100k simultâneas), channels, select, WaitGroup e padrões fan-in/fan-out. Com exemplos que rodam no playground.
Concorrência em Go
Uma das maiores forças do Go é seu modelo de concorrência, baseado em goroutines e channels. Diferente de threads tradicionais, goroutines são leves e gerenciadas pelo runtime do Go.
Goroutines
Uma goroutine é uma função executando concorrentemente com outras goroutines. Para criar uma goroutine, use a palavra-chave go:
package main
import (
"fmt"
"time"
)
func dizer(msg string) {
for i := 0; i < 3; i++ {
fmt.Println(msg)
time.Sleep(100 * time.Millisecond)
}
}
func main() {
go dizer("goroutine") // executa concorrentemente
dizer("main") // executa na goroutine principal
}
Características das Goroutines
- Leves: ~2KB de stack (vs ~1MB para threads OS)
- Multiplexadas: milhares podem rodar em poucos threads OS
- Gerenciadas pelo runtime: scheduling automático
// Criar 1000 goroutines é trivial
for i := 0; i < 1000; i++ {
go func(n int) {
fmt.Println(n)
}(i)
}
Channels
Channels são a forma idiomática de comunicação entre goroutines. Seguem o princípio:
Padrões de Concorrência em Go: Worker Pools, Fan-Out e Pipelines
Domine padrões de concorrência em Go: worker pools, fan-out/fan-in, pipelines, rate limiting e context para cancelamento. Exemplos práticos e prontos para uso.
Go nasceu para concorrência. Goroutines leves, channels tipados e o modelo CSP (Communicating Sequential Processes) tornam Go uma das linguagens mais produtivas para escrever código concorrente. Mas goroutines e channels são primitivas — para resolver problemas reais, você precisa de padrões.
Neste guia, vamos cobrir os padrões de concorrência mais importantes em Go, com exemplos prontos para produção. Se você ainda não domina os fundamentos, comece pelo nosso guia de concorrência em Go.
Go Concurrency Patterns: Goroutines e Channels Avançados
Aprenda patterns avançados de concorrência em Go: worker pools, fan-out/fan-in, rate limiting com channels, e context package. Tutorial completo com exemplos práticos de código.
A concorrência é um dos recursos mais poderosos de Go. Enquanto muitas linguagens tratam concorrência como um recurso avançado complexo, Go a torna acessível através de goroutines e channels. Este tutorial explora patterns avançados que você encontrará em aplicações Go de produção.
Pré-requisitos: Conhecimento básico de Go (variáveis, funções, structs) e familiaridade com goroutines e channels. Se você é novo em Go, confira nosso guia para iniciantes.
Sumário dos Patterns
| Pattern | Use Case | Complexidade |
|---|---|---|
| Worker Pool | Processar tarefas em paralelo com controle | Intermediario |
| Fan-Out/Fan-In | Distribuir trabalho e agregar resultados | Avancado |
| Pipeline | Processar dados em estágios sequenciais | Intermediario |
| Rate Limiting | Controlar throughput de requisições | Avancado |
| Context Cancellation | Cancelar operações de forma segura | Intermediario |
| Select Statement | Multiplexar channels | Avancado |
1. Worker Pool Pattern
O pattern Worker Pool é essencial quando você precisa processar um grande número de tarefas de forma concorrente, mas quer limitar o número de goroutines simultâneas.
Concorrência em Go: Goroutines e Channels - Guia Completo
Domine concorrência em Go. Tutorial completo sobre goroutines, channels, select, sync e padrões de concorrência. Exemplos práticos para iniciantes.
A concorrência é uma das features mais poderosas e distintivas de Go. Enquanto outras linguagens tornam a programação paralela complexa e cheia de boilerplate, Go a torna simples e elegante com goroutines e channels.
Neste quarto artigo da série “Golang para Iniciantes”, vamos desvendar os segredos da concorrência em Go. Você aprenderá a executar múltiplas tarefas simultaneamente de forma segura e eficiente.
Se você está chegando agora: