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 entorno de ejecución de Go. A diferencia de los hilos tradicionales, que consumen una cantidad significativa de memoria, las goroutines comienzan con solo unos pocos kilobytes de espacio de pila, lo que te permite ejecutar miles de ellas simultáneamente.

Para iniciar una gorutina, 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 concurrentemente
    go sayHello("Bob")    // se ejecuta concurrentemente
    
    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 con la siguiente línea mientras sayHello se ejecuta en segundo plano. Por eso necesitamos time.Sleep; sin él, main terminaría antes de que se completaran las goroutines.

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

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

La función principal se ejecuta en una goroutine. Cuando retorna, todas las demás goroutines terminan inmediatamente. No tienen la oportunidad de finalizar. Usar time.Sleep es una solución temporal; en las próximas lecciones, aprenderás técnicas de sincronización adecuadas con canales y grupos de espera.

Desafío

Fácil

Construyamos un ejecutor de tareas que ejecute varias tareas simultáneamente mediante goroutines. Crearás un sistema sencillo en el que las tareas se ejecutan en segundo plano mientras el programa principal continúa, demostrando cómo las goroutines permiten la ejecución simultánea.

Organizarás tu código en dos archivos:

tasks.go: Define la lógica de ejecución de tareas.
Crea una estructura Task con campos Name (string) y Duration (int, que representa milisegundos).

Implementa un método Run() en Task que simule trabajo durmiendo durante la duración de la tarea y, después, 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 finalicen y, después, imprimir: All tasks launched
main.go: Lee la información de las tareas y coordina la ejecución simultánea.
Lee el número de tareas y, después, lee el nombre y la duración de cada tarea. Crea las tareas y pásalas a RunAllTasks. Cuando esta función regrese, 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 y, después, su duración en milisegundos

Por ejemplo, dada la siguiente entrada:

3
Download
100
Process
50
Upload
75

Tu salida debe mostrar las tareas finalizadas (el orden puede variar debido a la ejecución simultánea), seguidas de los mensajes de finalización:

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

Nota: Como las goroutines se ejecutan simultáneamente, las tareas con duraciones más cortas normalmente terminan primero. El orden de finalización de las tareas depende de sus duraciones: las tareas más cortas terminan antes que las más largas.

Usa time.Sleep con time.Duration y time.Millisecond para las demoras. Recuerda que, sin la pausa en RunAllTasks, la función regresaría antes de que las goroutines terminaran su trabajo.

Pruébalo tú mismo

package main

import (
	"fmt"
)

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

	// TODO: Crea un slice para contener las tareas
	
	// TODO: Lee el nombre y la duración de cada tarea
	// Para cada tarea:
	//   - Lee el nombre de la tarea
	//   - Lee la duración (como entero)
	//   - Crea un Task y añádelo a tu slice

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

	// TODO: Print "Main function done"
}