Hablemos de ... Goroutines

Una de las peculiaridades del lenguaje Go son las goroutines, la cual es una forma de crear hilos de ejecución livianos y gestionables por el sistema operativo (un concepto similar a los hilos en Java).

Una goroutine se considera una unidad ligera de ejecución en Go. Se lanzan con la palabra go y las gestiona el runtime de Go (scheduler). Son mucho más ligeras que los hilos del sistema operativo.

Digamos que es una función o método que se ejecuta simultáneamente con otras goroutines en el mismo espacio de direcciones.

Características principales:

• Es una función que se ejecuta concurrentemente con otras dentro del mismo programa. 
• Ocupan muy poca memoria (unos pocos KB frente a MB de un hilo). 
• No dependen del sistema operativo, sino del runtime de Go, que las programa sobre un conjunto de hilos del sistema.
• Se lanzan en microsegundos, mucho más rápido que crear un hilo.

Las goroutines son abstracciones de concurrencia más eficientes que los hilos, aunque internamente se apoyan en un pool de hilos gestionados por Go. Son similares a los hilos de Java, pero más eficientes y con mejor gestión. Son ideales para tareas paralelas como servidores web, procesamiento de datos, o cualquier operación que pueda ejecutarse en segundo plano.

Para usar las goroutines nosotros debemos:

• Siempre usar canales (chan) para sincronizar y comunicar datos entre goroutines. 
• Evitar condiciones de carrera: aunque son ligeras, comparten memoria, por lo que hay que coordinar acceso concurrente.

Empezando con las goroutines

Crearemos un sencillo "Hola, mundo" usando goroutines.

main.go

package main

import (
    "fmt"
    "time"
)

func saludar(nombre string) {
    fmt.Println("Hola,", nombre)
}

func main() {
    go saludar("Alquimista") // se ejecuta concurrentemente
    go saludar("Mundo")   // otra goroutine

    // Esperamos un poco para que las goroutines terminen
    time.Sleep(time.Second)
    fmt.Println("Programa terminado")
}

Lanzamos la función como goroutine. El programa principal no espera a que termine esa función.

Usamos time.Sleep para dar tiempo a que las goroutines se ejecuten antes de que finalice main.

Compilamos y ejecutamos:

$ go build main.go
$ ./main

Salida:

Hola, Mundo
Hola, Alquimista
Programa terminado

Ahora calculemos la aceleración dada una velocidad final (30 m/s), una velocidad inicial (10 m/s) y un tiempo determinado (4s).

main.go

package main

import (
    "fmt"
    "time"
)


func calcularAceleracion(vf, vi, t float64, resultado chan float64) {
    aceleracion := (vf - vi) / t
    resultado <- aceleracion // enviamos el resultado al canal
}

func main() {
    vf := 30.0 // velocidad final (m/s)
    vi := 10.0 // velocidad inicial (m/s)
    t := 4.0   // tiempo (s)

    resultado := make(chan float64)

    go calcularAceleracion(vf, vi, t, resultado)

    fmt.Println("Calculando aceleración en segundo plano...")

    aceleracion := <-resultado
    fmt.Printf("La aceleración es: %.2f m/s²\n", aceleracion)

    time.Sleep(time.Second)
    fmt.Println("Programa terminado")
}

En este programa:

• Creamos un canal resultado para comunicar la goroutine con main. 
• La función calcularAceleracion se ejecuta como goroutine y envía el valor calculado al canal. 
• El main recibe el valor con <-resultado y lo imprime.

Esto permite que el cálculo se haga concurrentemente, mientras el programa principal puede seguir ejecutando otras tareas.

Compilamos y ejecutamos:

$ go build main.go
$ ./main

Salida:

Calculando aceleración en segundo plano...
La aceleración es: 5.00 m/s²
Programa terminado

Hemos visto que las goroutines son muy útiles para los desarrollos modernos donde la concurrencia y la eficiencia en la gestión de recursos es muy importante.

Vamos a continuar con este tema en próximas entregas.

Enlaces:

https://go.dev/
https://gobyexample.com/
https://alquimistadecodigo.blogspot.com/2025/12/creando-proyectos-con-go.html
https://alquimistadecodigo.blogspot.com/2026/04/creando-proyectos-go-con-go-blueprint.html