Fundamentos de Goroutines

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy — lección 59 de 107.

Una goroutine es un hilo de ejecución ligero gestionado por el Go runtime. A diferencia de los hilos tradicionales que consumen una memoria significativa, las goroutines comienzan con solo unos pocos kilobytes de espacio de pila, lo que permite ejecutar miles de ellas de forma concurrente.

Para iniciar una goroutine, simplemente coloca la palabra clave go antes de una llamada a una función:

func sayHello(name string) {
    fmt.Println("Hello,", name)
}

func main() {
    go sayHello("Alice")  // se ejecuta de forma concurrente
    go sayHello("Bob")    // se ejecuta de forma concurrente
    
    time.Sleep(100 * time.Millisecond)
    fmt.Println("Done")
}

Cuando go sayHello("Alice") se ejecuta, no espera a que sayHello termine. En su lugar, continúa inmediatamente a la siguiente línea mientras sayHello se ejecuta en segundo plano. Por eso necesitamos time.Sleep; sin él, main terminaría antes de que las goroutines finalicen.

También puedes iniciar goroutines con funciones anónimas:

go func(msg string) {
    fmt.Println(msg)
}("Hello from goroutine")

La propia función main se ejecuta en una goroutine. Cuando esta retorna, todas las demás goroutines finalizan inmediatamente; no tienen oportunidad de terminar. El uso de time.Sleep es una solución temporal; en las próximas lecciones, aprenderás técnicas de sincronización adecuadas con canales y wait groups.

Desafío

Fácil

Vamos a construir un ejecutor de tareas que ejecute múltiples tareas de forma concurrente utilizando goroutines. Crearás un sistema sencillo donde las tareas se ejecutan en segundo plano mientras el programa principal continúa, demostrando cómo las goroutines permiten la ejecución concurrente.

Organizarás tu código en dos archivos:

tasks.go: Define tu lógica de ejecución de tareas.
Crea un struct Task con los campos Name (string) y Duration (int, que representa milisegundos).

Implementa un método Run() en Task que simule el trabajo durmiendo durante la duración de la tarea, y luego imprima: Task [Name] completed

Crea una función RunAllTasks(tasks []Task) que inicie el método Run() de cada tarea como una goroutine. Después de iniciar todas las goroutines, debe dormir durante 500 milisegundos para permitir que se completen, y luego imprimir: All tasks launched
main.go: Lee la información de las tareas y orquestar la ejecución concurrente.
Lee el número de tareas, luego lee el nombre y la duración de cada tarea. Crea las tareas y pásalas a RunAllTasks. Después de que retorne, imprime: Main function done

Se proporcionarán las siguientes entradas:

Línea 1: Número de tareas (entero)
Líneas siguientes: Para cada tarea, dos líneas - el nombre de la tarea, luego su duración en milisegundos

Por ejemplo, dado:

3
Download
100
Process
50
Upload
75

Tu salida debería mostrar las tareas completándose (el orden puede variar debido a la concurrencia), seguido de los mensajes de finalización:

Task Process completed
Task Upload completed
Task Download completed
All tasks launched
Main function done

Nota: Dado que las goroutines se ejecutan de forma concurrente, las tareas con duraciones más cortas suelen terminar primero. El orden de finalización de las tareas depende de sus duraciones: las tareas más cortas se completan antes que las más largas.

Usa time.Sleep con time.Duration y time.Millisecond para los retardos. Recuerda que sin el sleep en RunAllTasks, la función retornaría antes de que las goroutines terminen su trabajo.

Hoja de referencia

Una goroutine es un hilo de ejecución ligero gestionado por el entorno de ejecución de Go (Go runtime). Las goroutines comienzan con solo unos pocos kilobytes de espacio de pila, lo que permite ejecutar miles de ellas de forma concurrente.

Para iniciar una goroutine, coloca la palabra clave go antes de una llamada a una función:

func sayHello(name string) {
    fmt.Println("Hello,", name)
}

func main() {
    go sayHello("Alice")  // se ejecuta de forma concurrente
    go sayHello("Bob")    // se ejecuta de forma concurrente
    
    time.Sleep(100 * time.Millisecond)
    fmt.Println("Done")
}

Cuando se ejecuta go sayHello("Alice"), no espera a que sayHello termine. En su lugar, continúa inmediatamente a la siguiente línea mientras sayHello se ejecuta en segundo plano.

Puedes iniciar goroutines con funciones anónimas:

go func(msg string) {
    fmt.Println(msg)
}("Hello from goroutine")

La función main en sí misma se ejecuta en una goroutine. Cuando retorna, todas las demás goroutines terminan inmediatamente. Usa time.Sleep para permitir que las goroutines se completen antes de que la función main finalice.

Pruébalo tú mismo

package main

import (
	"fmt"
)

func main() {
	// Leer el número de tareas
	var numTasks int
	fmt.Scanln(&numTasks)

	// TODO: Crear un slice para contener las tareas
	
	// TODO: Leer el nombre y la duración de cada tarea
	// Para cada tarea:
	//   - Leer el nombre de la tarea
	//   - Leer la duración (como entero)
	//   - Crear una Task y añadirla a tu slice

	// TODO: Llamar a RunAllTasks con tu slice de tareas

	// TODO: Imprimir "Main function done"
}