Em que as goroutines diferem dos threads (fios)?

As goroutines diferem dos threads (fios) nos seguintes aspetos-chave:

• Gestão: As goroutines são geridas pelo ambiente de execução do Go, enquanto que os threads são geridos pelo sistema operativo. Isto torna a troca entre goroutines muito mais leve e rápida, pois não requer mudança de contexto do núcleo.
• Custos: Criar e gerir goroutines requer muito menos recursos (memória e tempo) em comparação com os threads. Uma goroutine começa com uma pilha muito pequena (alguns quilobytes), que pode crescer ou diminuir dinamicamente conforme necessário, enquanto que os threads têm uma pilha fixa, muitas vezes muito maior.
• Escalabilidade: Graças aos seus baixos custos, é fácil criar centenas de milhares ou mesmo milhões de goroutines numa única aplicação, enquanto que criar a mesma quantidade de threads rapidamente esgota os recursos do sistema.
• Planeamento: O agendador do Go multiplexa muitas goroutines num menor número de threads do sistema operativo. Isto implementa a multitarefa cooperativa entre goroutines num único thread do sistema operativo (embora com elementos de preempção), enquanto que os threads do sistema operativo são geridos pelo agendador do sistema operativo, que utiliza multitarefa preemptiva.

Aspeto	Goroutines	Threads
Gestão	Ambiente de execução do Go	Sistema operativo
Custos	Baixos (memória, tempo)	Altos (memória, tempo)
Escalabilidade	Muito alta	Limitada pelos recursos do sistema
Planeamento	Agendador do Go (cooperativo)	Agendador do SO (preemptivo)
Pilha	Dinâmica, pequena	Fixa, muitas vezes grande

Exemplo de criação de uma goroutine:

package main

import (
	"fmt"
	"time"
)

func tarefa(id int) {
	fmt.Printf("Goroutine %d começou\n", id)
	time.Sleep(time.Second)
	fmt.Printf("Goroutine %d terminou\n", id)
}

func main() {
	go tarefa(1) // Criação de uma goroutine
	go tarefa(2) // Criação de outra goroutine

	time.Sleep(2 * time.Second) // Esperar que as goroutines terminem
	fmt.Println("Goroutine principal terminada")
}