Recapitulaçã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 construir um sistema de processamento de tarefas usando o padrão worker pool! Você criará um pool de trabalhadores (workers) que processam tarefas computacionais de forma concorrente, 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 seu worker pool.
Crie uma struct Task com os campos ID (int) e Value (int) representando o trabalho a ser feito.

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

Implemente uma função Worker que recebe um ID de worker (int), um canal de tarefas apenas para recebimento (<-chan Task), um canal para resultados apenas para envio (chan<- Result) e um ponteiro para um sync.WaitGroup. Cada worker deve:
- Usar defer wg.Done() para sinalizar a conclusão
- Percorrer (range) o canal de tarefas para processar cada tarefa
- Para cada tarefa, calcular o quadrado do campo Value da tarefa
- Enviar um Result com o TaskID e o quadrado calculado
Implemente uma função RunPool que recebe o número de workers (int) e um slice de tarefas. Esta função deve:
- Criar canais com buffer para tarefas e resultados (use o número de tarefas como o 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 após todos os workers terminarem
- Coletar todos os resultados em um slice e retorná-lo
main.go: Leia a entrada e coordene o worker pool.
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, depois imprima cada resultado no formato: Task [TaskID]: [Computed]

Imprima os resultados ordenados pelo 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, dado:

Sua saída deve ser:

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

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

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