Pattern del worker pool
Limitare la concorrenza
Pattern del worker pool è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.
Che cos'è un worker pool
Un worker pool avvia un numero fisso di goroutine che prelevano tutte i job da un canale condiviso. Invece di creare una goroutine per ogni attività, avvia N worker e assegna loro il lavoro.
- Limita il numero di operazioni concorrenti
- Riutilizza le goroutine invece di crearne migliaia
- Protegge risorse condivise come database o API
Perché limitare la concorrenza
Le goroutine senza limiti possono esaurire la memoria o i descrittori di file, oppure sovraccaricare un servizio a valle. Un pool offre un parametro per controllare quanto lavoro viene eseguito contemporaneamente.
Se deve recuperare 10000 URL, non vuole 10000 richieste HTTP simultanee. Un pool di 20 worker mantiene il carico sotto controllo.
Il canale jobs
I job confluiscono in un canale jobs. Ogni worker lo legge in un ciclo for range. Quando il canale viene chiuso, il ciclo termina e il worker esce.
jobs := make(chan int, 100)
for j := 1; j <= 5; j++ {
jobs <- j
}
close(jobs)Un singolo worker
Un worker è semplicemente una funzione che itera sul canale jobs. Elabora ogni job e scrive il risultato in un canale dei risultati.
func worker(id int, jobs <-chan int, results chan<- int) {
for j := range jobs {
results <- j * 2
}
}Avviare più worker
Avvii il pool con un semplice ciclo. A ogni iterazione avvii una goroutine che esegue la stessa funzione worker. Tutte condividono gli stessi canali jobs e results.
for w := 1; w <= 3; w++ {
go worker(w, jobs, results)
}Tipi di canale direzionali
Noti <-chan int, di sola ricezione, e chan<- int, di sola trasmissione, nella firma del worker. Questi tipi direzionali consentono al compilatore di impedire che un worker invii accidentalmente dati in jobs o legga da results.
Raccogliere i risultati
Dopo aver inserito tutti i job e chiuso il canale, la goroutine principale legge esattamente tanti risultati quanti erano i job. In questo modo sincronizza il programma, impedendogli di terminare in anticipo.
sum := 0
for a := 1; a <= 5; a++ {
sum += <-results
}
fmt.Println("total:", sum)Un pool completo ed eseguibile
Ecco il pattern completo in un unico programma: tre worker raddoppiano cinque numeri. Lo esegua e osservi il totale.
package main
import "fmt"
func worker(id int, jobs <-chan int, results chan<- int) {
for j := range jobs {
results <- j * 2
}
}
func main() {
jobs := make(chan int, 5)
results := make(chan int, 5)
for w := 1; w <= 3; w++ {
go worker(w, jobs, results)
}
for j := 1; j <= 5; j++ {
jobs <- j
}
close(jobs)
total := 0
for a := 1; a <= 5; a++ {
total += <-results
}
fmt.Println("total:", total)
}Con buffer o senza buffer
Un canale jobs con buffer consente al produttore di accodare il lavoro senza bloccarsi finché il buffer non si riempie. Un canale senza buffer forza un passaggio diretto: l'invio si blocca finché un worker non è pronto. Il buffer rende più regolare il flusso dei produttori a raffiche.
Scegliere la dimensione del pool
Per il lavoro vincolato dalla CPU, dimensioni il pool in prossimità di runtime.NumCPU(). Per il lavoro vincolato dall'I/O, ad esempio rete o disco, può usare un numero molto maggiore, poiché i worker trascorrono il tempo in attesa anziché nell'elaborazione.
package main
import (
"fmt"
"runtime"
)
func main() {
fmt.Println("CPUs:", runtime.NumCPU())
}Evitare le perdite di goroutine
Se dimentica di close(jobs), i worker restano bloccati per sempre su un canale vuoto e si verifica una perdita di goroutine. Chiuda sempre il canale jobs dopo aver inviato tutto il lavoro, così i cicli for range terminano.
Verifica rapida
Verifichi la Sua comprensione dei pool di worker.
Riepilogo
Ha imparato il pattern del pool di worker:
- Avviare un numero fisso di worker che leggono da un canale jobs condiviso
- Utilizzare tipi di canale direzionali per maggiore sicurezza
- Chiudere il canale jobs per terminare i worker
- Raccogliere i risultati per sincronizzare il completamento
- Dimensionare il pool in base al tipo di carico (CPU o I/O)
Domande Frequenti
La lezione «Pattern del worker pool» è gratuita?
Sì — il testo completo di «Pattern del worker pool» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.
Cosa imparerò in «Pattern del worker pool»?
Limitare la concorrenza Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Go Academy?
Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Pattern del worker pool»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Go Academy?
Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Pattern del worker pool
- Fan-out e fan-in
- Fasi della pipeline
- Arresto graduale