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

¡Construyamos un sistema de procesamiento de tareas usando el patrón de grupo de trabajadores! Crearás un grupo de trabajadores que procesará tareas computacionales de forma concurrente, demostrando cómo los canales, las gorutinas y los WaitGroups trabajan juntos para gestionar las cargas de trabajo de manera eficiente.

Organizarás tu código en dos archivos:

pool.go: Define los componentes y la lógica del grupo de trabajadores.
Crea una estructura Task con campos ID (int) y Value (int) que representen el trabajo que se debe realizar.

Crea una estructura Result con campos TaskID (int) y Computed (int) que representen 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 indicar que ha terminado
- Recorrer 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 un slice de tareas. Esta función debe:
- Crear canales con búfer para las tareas y los resultados (usar el número de tareas como tamaño del búfer)
- Iniciar el número especificado de trabajadores como gorutinas
- Enviar todas las tareas al canal de tareas y después cerrarlo
- Usar una gorutina con el WaitGroup para cerrar el canal de resultados después de que todos los trabajadores terminen
- Recopilar todos los resultados en un slice y devolverlo
main.go: Lee la entrada y coordina el grupo de trabajadores.
Lee el número de trabajadores y después el número de tareas. Para cada tarea, lee su ID y su valor. Llama a RunPool con los trabajadores y las tareas, y después imprime cada resultado con 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) y después su valor (entero)

Por ejemplo, dada la siguiente entrada:

Tu salida debe 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 recopilan y muestran ordenados por ID de tarea. Con 2 trabajadores gestionando 4 tareas, el trabajo se distribuye eficientemente entre el grupo.

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]
}