Rückblick – Worker Pool

Teil des Abschnitts Objektorientierte Programmierung der GO-Journey von Coddy. Lektion 66 von 107.

Aufgabe

Einfach

Lassen Sie uns ein Aufgabenverarbeitungssystem nach dem Worker-Pool-Muster erstellen! Sie werden einen Pool von Workern erstellen, die Rechenaufgaben gleichzeitig verarbeiten, und so demonstrieren, wie Channels, Goroutinen und WaitGroups zusammenarbeiten, um Arbeitslasten effizient zu bewältigen.

Sie werden Ihren Code auf zwei Dateien verteilen:

pool.go: Definieren Sie Ihre Worker-Pool-Komponenten und die Logik.
Erstellen Sie ein Task-Struct mit den Feldern ID (int) und Value (int), die die zu erledigende Arbeit repräsentieren.

Erstellen Sie ein Result-Struct mit den Feldern TaskID (int) und Computed (int), die die abgeschlossene Arbeit repräsentieren.

Implementieren Sie eine Worker-Funktion, die eine Worker-ID (int), einen Empfangskanal für Aufgaben (<-chan Task), einen Sendekanal für Ergebnisse (chan<- Result) und einen Zeiger auf eine sync.WaitGroup entgegennimmt. Jeder Worker sollte:
- defer wg.Done() verwenden, um den Abschluss zu signalisieren
- Über den Aufgaben-Channel iterieren (range), um jede Aufgabe zu verarbeiten
- Für jede Aufgabe das Quadrat des Value der Aufgabe berechnen
- Ein Result mit der TaskID und dem berechneten Quadrat senden
Implementieren Sie eine RunPool-Funktion, die die Anzahl der Worker (int) und eine Slice von Aufgaben entgegennimmt. Diese Funktion sollte:
- Gepufferte Channels für Aufgaben und Ergebnisse erstellen (verwenden Sie die Anzahl der Aufgaben als Puffergröße)
- Die angegebene Anzahl von Workern als Goroutinen starten
- Alle Aufgaben an den Aufgaben-Channel senden und diesen dann schließen
- Eine Goroutine mit der WaitGroup verwenden, um den Ergebnis-Channel zu schließen, nachdem alle Worker fertig sind
- Alle Ergebnisse in einer Slice sammeln und diese zurückgeben
main.go: Eingaben lesen und den Worker-Pool koordinieren.
Lesen Sie die Anzahl der Worker und dann die Anzahl der Aufgaben ein. Lesen Sie für jede Aufgabe deren ID und Wert ein. Rufen Sie RunPool mit den Workern und Aufgaben auf und geben Sie dann jedes Ergebnis im Format Task [TaskID]: [Computed] aus.

Geben Sie die Ergebnisse nach TaskID aufsteigend sortiert aus.

Die folgenden Eingaben werden bereitgestellt:

Zeile 1: Anzahl der Worker (Ganzzahl)
Zeile 2: Anzahl der Aufgaben (Ganzzahl)
Folgende Zeilen: Für jede Aufgabe zwei Zeilen - die Aufgaben-ID (Ganzzahl), dann ihr Wert (Ganzzahl)

Zum Beispiel bei folgender Eingabe:

Sollte Ihre Ausgabe wie folgt aussehen:

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

Die Worker verarbeiten Aufgaben gleichzeitig (3 zum Quadrat ist 9, 5 zum Quadrat ist 25 usw.), und die Ergebnisse werden gesammelt und nach Aufgaben-ID sortiert angezeigt. Mit 2 Workern, die 4 Aufgaben bearbeiten, wird die Arbeit effizient über den Pool verteilt.

Probier es selbst

package main

import (
	"fmt"
	"sort"
)

func main() {
	// Anzahl der Arbeiter lesen
	var numWorkers int
	fmt.Scanln(&numWorkers)

	// Anzahl der Aufgaben lesen
	var numTasks int
	fmt.Scanln(&numTasks)

	// Aufgaben lesen
	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: RunPool mit Arbeitern und Aufgaben aufrufen

	// TODO: Ergebnisse nach TaskID in aufsteigender Reihenfolge sortieren

	// TODO: Jedes Ergebnis im Format ausgeben: Task [TaskID]: [Computed]
}