Revisão - Worker Pool

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy. Lição 66 de 107.

Desafio

Fácil

Vamos criar um sistema de processamento de tarefas usando o padrão de pool de workers! Você criará um pool de workers que processam tarefas computacionais simultaneamente, demonstrando como canais, goroutines e WaitGroups trabalham juntos para lidar com cargas de trabalho de forma eficiente.

Você organizará seu código em dois arquivos:

pool.go: Defina os componentes e a lógica do pool de workers.
Crie uma struct Task com campos ID (int) e Value (int) representando o trabalho a ser realizado.

Crie uma struct Result com campos TaskID (int) e Computed (int) representando o trabalho concluído.

Implemente uma função Worker que receba um ID de worker (int), um canal somente para recebimento de tarefas (<-chan Task), um canal somente para envio de resultados (chan<- Result) e um ponteiro para um sync.WaitGroup. Cada worker deve:
- Usar defer wg.Done() para sinalizar a conclusão
- Percorrer o canal de tarefas para processar cada tarefa
- Para cada tarefa, calcular o quadrado do Value da tarefa
- Enviar um Result com o TaskID e o quadrado calculado
Implemente uma função RunPool que receba o número de workers (int) e uma fatia de tarefas. Essa função deve:
- Criar canais com buffer para tarefas e resultados (use o número de tarefas como tamanho do buffer)
- Iniciar o número especificado de workers como goroutines
- Enviar todas as tarefas para o canal de tarefas e, em seguida, fechá-lo
- Usar uma goroutine com o WaitGroup para fechar o canal de resultados depois que todos os workers terminarem
- Coletar todos os resultados em uma fatia e retorná-la
main.go: Leia a entrada e coordene o pool de workers.
Leia o número de workers e, em seguida, o número de tarefas. Para cada tarefa, leia seu ID e valor. Chame RunPool com os workers e as tarefas e, em seguida, imprima cada resultado no formato: Task [TaskID]: [Computed]

Imprima os resultados ordenados por TaskID em ordem crescente.

As seguintes entradas serão fornecidas:

Linha 1: Número de workers (inteiro)
Linha 2: Número de tarefas (inteiro)
Linhas seguintes: Para cada tarefa, duas linhas — o ID da tarefa (inteiro) e, em seguida, seu valor (inteiro)

Por exemplo, considerando:

Sua saída deve ser:

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

Os workers processam as tarefas simultaneamente (3 ao quadrado é 9, 5 ao quadrado é 25 etc.), e os resultados são coletados e exibidos na ordem do ID da tarefa. Com 2 workers lidando com 4 tarefas, o trabalho é distribuído de forma eficiente pelo pool.

Experimente você mesmo

package main

import (
	"fmt"
	"sort"
)

func main() {
	// Ler número de trabalhadores
	var numWorkers int
	fmt.Scanln(&numWorkers)

	// Ler número de tarefas
	var numTasks int
	fmt.Scanln(&numTasks)

	// Ler tarefas
	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: Chamar RunPool com trabalhadores e tarefas

	// TODO: Ordenar resultados por TaskID em ordem crescente

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