Una goroutine es una función ligera que se ejecuta concurrentemente, gestionada por el runtime de Go. Lanzar una es tan simple como poner go antes de una llamada a función. Las goroutines son la característica de concurrencia distintiva de Go — mucho más económicas que los hilos del SO, por lo que puedes ejecutar miles o millones.
{
fmt.Println()
}
sayHello()
{
fmt.Println()
}()
La palabra clave go inicia la función en una nueva goroutine y regresa inmediatamente — el código que llama continúa sin 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).
Las goroutines no son hilos del SO — el planificador de Go multiplexea muchas goroutines en pocos hilos del SO. Esto las hace extraordinariamente económicas, permitiendo concurrencia masiva (por ejemplo, una goroutine por conexión en un servidor que maneja millones de conexiones).
func main() {
go sayHello() // ❌ main might EXIT before this goroutine runs → nothing printed
// program ends immediately
}
Cuando main regresa, el programa termina — matando cualquier goroutine aún en ejecución. Necesitas coordinar.
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 es la forma estándar de esperar a que un conjunto de goroutines se completen.
ch := make(chan string)
go func() { ch <- "result" }() // send a result on the channel
msg := <-ch // receive (blocks until a value arrives)
La filosofía de Go: "No comuniques compartiendo memoria; comparte memoria comunicándote" — usa channels para pasar datos entre goroutines en lugar de variables compartidas + locks.
Las goroutines son la característica definitoria de Go y la razón principal por la que destaca en sistemas concurrentes y en red.
Su extrema ligereza (kilobytes vs megabytes para hilos, programados M:N en hilos del SO) hace que la concurrencia masiva sea práctica y fácil — un servidor puede crear una goroutine por solicitud o conexión sin preocupaciones de recursos, lo que es difícil o imposible con hilos del SO.
Entender cómo lanzarlas (go), la necesidad crítica de sincronizar (main saliendo mata goroutines; usa WaitGroup para esperar), y la preferencia de Go por comunicar vía channels sobre memoria compartida es fundamental para escribir Go concurrente correcto.
Las goroutines (y los patrones alrededor de ellas) son centrales a la propuesta de valor de Go y entre los temas más importantes y frecuentemente evaluados en el lenguaje.