Resumen - Worker Pool

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

Desafío

Fácil

¡Vamos a construir un sistema de procesamiento de tareas utilizando el patrón de pool de trabajadores (worker pool)! Crearás un grupo de trabajadores que procesan tareas computacionales de forma concurrente, demostrando cómo los canales, las goroutines y los WaitGroups trabajan juntos para manejar cargas de trabajo de manera eficiente.

Organizarás tu código en dos archivos:

pool.go: Define los componentes y la lógica de tu pool de trabajadores.
Crea una estructura Task con los campos ID (int) y Value (int) que representan el trabajo a realizar.

Crea una estructura Result con los campos TaskID (int) y Computed (int) que representan el trabajo completado.

Implementa una función Worker que reciba un ID de trabajador (int), un canal de solo recepción de tareas (<-chan Task), un canal de solo envío para resultados (chan<- Result) y un puntero a un sync.WaitGroup. Cada trabajador debe:
- Usar defer wg.Done() para señalar la finalización
- Iterar (range) sobre el canal de tareas para procesar cada tarea
- Para cada tarea, calcular el cuadrado del Value de la tarea
- Enviar un Result con el TaskID y el cuadrado calculado
Implementa una función RunPool que reciba el número de trabajadores (int) y una rebanada (slice) de tareas. Esta función debe:
- Crear canales con búfer para tareas y resultados (usa el número de tareas como tamaño del búfer)
- Iniciar el número especificado de trabajadores como goroutines
- Enviar todas las tareas al canal de tareas y luego cerrarlo
- Usar una goroutine con el WaitGroup para cerrar el canal de resultados después de que todos los trabajadores terminen
- Recolectar todos los resultados en un slice y devolverlo
main.go: Lee la entrada y coordina el pool de trabajadores.
Lee el número de trabajadores, luego el número de tareas. Para cada tarea, lee su ID y su valor. Llama a RunPool con los trabajadores y las tareas, luego imprime cada resultado en el formato: Task [TaskID]: [Computed]

Imprime los resultados ordenados por TaskID en orden ascendente.

Se proporcionarán las siguientes entradas:

Línea 1: Número de trabajadores (entero)
Línea 2: Número de tareas (entero)
Líneas siguientes: Para cada tarea, dos líneas - el ID de la tarea (entero), luego su valor (entero)

Por ejemplo, dado:

Tu salida debería ser:

Task 1: 9
Task 2: 25
Task 3: 4
Task 4: 49

Los trabajadores procesan las tareas de forma concurrente (3 al cuadrado es 9, 5 al cuadrado es 25, etc.), y los resultados se recolectan y muestran en orden por el ID de la tarea. Con 2 trabajadores manejando 4 tareas, el trabajo se distribuye a través del pool de manera eficiente.

Pruébalo tú mismo

package main

import (
	"fmt"
	"sort"
)

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

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

	// Leer tareas
	tasks := make([]Task, numTasks)
	for i := 0; i < numTasks; i++ {
		var id, value int
		fmt.Scanln(&id)
		fmt.Scanln(&value)
		tasks[i] = Task{ID: id, Value: value}
	}

	// TODO: Llamar a RunPool con trabajadores y tareas

	// TODO: Ordenar los resultados por TaskID en orden ascendente

	// TODO: Imprimir cada resultado en el formato: Task [TaskID]: [Computed]
}