Uma goroutine é uma função leve, executada concorrentemente e gerenciada pelo runtime do Go. Iniciar uma é tão simples quanto colocar go antes de uma chamada de função. Goroutines são a funcionalidade de concorrência distintiva do Go — muito mais baratas que threads do SO, permitindo executar milhares ou milhões delas.
{
fmt.Println()
}
sayHello()
{
fmt.Println()
}()
A palavra-chave go inicia a função em uma nova goroutine e retorna imediatamente — o código que fez a chamada continua sem esperar.
OS thread: ~1–2 MB of memory each → thousands max
Goroutine: ~2 KB initial stack (grows as needed) → MILLIONS feasible
The Go runtime SCHEDULES many goroutines onto a small pool of OS threads (M:N).
Goroutines não são threads do SO — o scheduler do Go multiplexam muitas goroutines em poucas threads do SO. Isso as torna extraordinariamente baratas, viabilizando concorrência massiva (ex: uma goroutine por conexão em um servidor tratando milhões de conexões).
func main() {
go sayHello() // ❌ main might EXIT before this goroutine runs → nothing printed
// program ends immediately
}
Quando main retorna, o programa encerra — matando qualquer goroutine ainda em execução. Você precisa coordenar.
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
wg.Add(1) // increment the counter
go func(n int) {
defer wg.Done() // decrement when this goroutine finishes
fmt.Println("worker", n)
}(i) // pass i as an argument (avoid the loop-var capture bug)
}
wg.Wait() // BLOCK until all goroutines call Done()
sync.WaitGroup é a forma padrão de esperar que um conjunto de goroutines se complete.
ch := make(chan string)
go func() { ch <- "result" }() // send a result on the channel
msg := <-ch // receive (blocks until a value arrives)
A filosofia do Go: "Não comunique compartilhando memória; compartilhe memória comunicando" — use channels para passar dados entre goroutines em vez de variáveis compartilhadas + locks.
Goroutines são a funcionalidade definidora do Go e a principal razão pela qual ele se destaca em sistemas concorrentes e em rede.
Sua extrema leveza (kilobytes versus megabytes para threads, agendadas M:N em threads do SO) torna a concorrência massiva prática e fácil — um servidor pode criar uma goroutine por requisição ou conexão sem preocupações com recursos, o que é difícil ou impossível com threads do SO.
Compreender como iniciá-las (go), a necessidade crítica de sincronização (main saindo mata goroutines; use WaitGroup para esperar), e a preferência do Go por comunicar via channels em vez de memória compartilhada é fundamental para escrever Go concorrente correto.
Goroutines (e os padrões ao seu redor) são centrais para a proposta de valor do Go e entre os tópicos mais importantes e frequentemente testados na linguagem.