Worker-Pool-Pattern
Einen Worker-Pool mit fester Anzahl von Goroutines erstellen
Worker-Pool-Pattern ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.
Was ist ein Worker-Pool?
Ein Worker-Pool erstellt vorab eine feste Anzahl von Goroutinen, die Aufträge aus einer gemeinsam genutzten Warteschlange verarbeiten. Dadurch wird die Nebenläufigkeit begrenzt und eine Erschöpfung der Ressourcen durch das unbegrenzte Erstellen von Goroutinen verhindert.
Grundlegende Implementierung
Erstellen Sie einen jobs-Kanal und N Goroutinen, die alle daraus lesen:
func workerPool(n int, jobs <-chan Job, results chan<- Result) {
var wg sync.WaitGroup
for i := 0; i < n; i++ {
wg.Add(1)
go func() {
defer wg.Done()
for job := range jobs {
results <- process(job)
}
}()
}
wg.Wait()
close(results)
}Aufträge senden
Senden Sie alle Aufträge an den Kanal und schließen Sie ihn anschließend. Die Worker verarbeiten alle Aufträge und verlassen ihre Bereichsschleifen, sobald der Kanal geschlossen wird.
jobs := make(chan Job, 100)
for _, j := range allJobs {
jobs <- j
}
close(jobs) // signals workers to stop after drainingErgebnisse sammeln
Lesen Sie Ergebnisse parallel zum Senden der Aufträge. Verwenden Sie für den Pool eine Goroutine, damit das Sammeln der Ergebnisse nicht durch die Übermittlung von Aufträgen blockiert wird.
results := make(chan Result, 100)
go workerPool(5, jobs, results)
for r := range results {
collect(r)
}Poolgröße abstimmen
Setzen Sie die Poolgröße bei CPU-gebundener Arbeit auf runtime.NumCPU(). Bei E/A-gebundener Arbeit nutzt ein höherer Multiplikator (z. B. 10×) die Wartezeit besser aus. Ermitteln Sie durch Profiling den optimalen Wert.
n := runtime.NumCPU()
if ioHeavy { n = runtime.NumCPU() * 10 }Abbruch mit Kontext hinzufügen
Übergeben Sie den Workern einen Kontext, damit sie bei einem Abbruch vorzeitig stoppen:
for {
select {
case job, ok := <-jobs:
if !ok { return }
results <- process(ctx, job)
case <-ctx.Done():
return
}
}Alternative mit Semaphore
Verwenden Sie statt eines festen Goroutine-Pools einen gepufferten Kanal als Semaphore, um die Anzahl gleichzeitig ausgeführter Goroutinen zu begrenzen und dennoch pro Auftrag eine Goroutine zu starten.
sem := make(chan struct{}, 10)
for _, job := range jobs {
sem <- struct{}{}
go func(j Job) {
defer func() { <-sem }()
process(j)
}(job)
}Fehlerbehandlung
Geben Sie Fehler zusammen mit Ergebnissen mithilfe einer Ergebnisstruktur zurück. Brechen Sie den Kontext beim ersten Fehler ab oder sammeln Sie alle Fehler für einen abschließenden Bericht.
type Result struct{ Val int; Err error }Dynamische Poolgröße
Verwenden Sie für adaptive Pools golang.org/x/sync/semaphore. Damit können gewichtete Ressourcen erworben und freigegeben werden, was dynamische Grenzen für die Nebenläufigkeit ermöglicht.
Worker-Pool im Vergleich zu errgroup
golang.org/x/sync/errgroup bietet eine einfachere API zum Starten von N Goroutinen und zum Sammeln des ersten Fehlers. Verwenden Sie einen Pool, wenn Sie eine dauerhafte Gruppe wiederverwendbarer Worker benötigen.
Kontrolliertes Herunterfahren
Schließen Sie den jobs-Kanal, um die Worker zu benachrichtigen. Schließen Sie results, sobald die WaitGroup abgeschlossen ist. Alle ausstehenden Aufträge müssen vor close(jobs) übermittelt werden.
Kurze Überprüfung
Wie signalisiert ein Worker-Pool den Workern, dass sie die Verarbeitung beenden sollen?
Zusammenfassung: Worker-Pool
Wichtige Punkte:
- Eine feste Anzahl von N Goroutinen liest aus einem jobs-Kanal
- Schließen Sie den jobs-Kanal, um den Workern das Beenden zu signalisieren
- WaitGroup verfolgt den Abschluss; schließen Sie results, sobald alle fertig sind
- CPU-gebunden: Poolgröße ≈ NumCPU; E/A-gebunden: größer
Lerne Go mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 51
- Lektionen
- 203
Häufig gestellte Fragen
Ist die Lektion „Worker-Pool-Pattern“ kostenlos?
Ja — der vollständige Text von „Worker-Pool-Pattern“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Worker-Pool-Pattern“?
Einen Worker-Pool mit fester Anzahl von Goroutines erstellen Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Go Academy zu starten?
Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „Worker-Pool-Pattern“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?
Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Die select-Anweisung
- Timeouts und Ticker
- Fan-in- und Fan-out-Patterns
- Worker-Pool-Pattern