Go Academy · Lezione

Modello del worker pool

Creare un worker pool di goroutine a dimensione fissa

Modello del worker pool è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 4 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 crea in anticipo un numero fisso di goroutine che elaborano i lavori da una coda condivisa. In questo modo limita la concorrenza ed evita l'esaurimento delle risorse dovuto alla creazione illimitata di goroutine.

Implementazione di base

Crei un canale jobs e N goroutine che leggano tutte da esso:

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

Invio dei lavori

Invii tutti i lavori al canale, quindi lo chiuda. I worker elaboreranno tutti i lavori e usciranno dai rispettivi cicli range quando il canale verrà chiuso.

jobs := make(chan Job, 100)
for _, j := range allJobs {
    jobs <- j
}
close(jobs) // signals workers to stop after draining

Raccolta dei risultati

Legga i risultati contemporaneamente all'invio dei lavori. Usi una goroutine per il pool, così la raccolta dei risultati non entra in deadlock con l'invio dei lavori.

results := make(chan Result, 100)
go workerPool(5, jobs, results)
for r := range results {
    collect(r)
}

Regolazione delle dimensioni del pool

Per il lavoro vincolato dalla CPU, imposti la dimensione del pool su runtime.NumCPU(). Per il lavoro vincolato dall'I/O, un moltiplicatore più alto (ad esempio 10×) sfrutta il tempo di attesa. Esegua il profiling per trovare il punto ottimale.

n := runtime.NumCPU()
if ioHeavy { n = runtime.NumCPU() * 10 }

Aggiunta dell'annullamento tramite context

Passi un context ai worker, così possono arrestarsi in anticipo quando l'operazione viene annullata:

for {
    select {
    case job, ok := <-jobs:
        if !ok { return }
        results <- process(ctx, job)
    case <-ctx.Done():
        return
    }
}

Alternativa con semaforo

Invece di un pool fisso di goroutine, usi un canale con buffer come semaforo per limitare il numero di goroutine eseguite contemporaneamente, continuando però a crearne una per ogni lavoro.

sem := make(chan struct{}, 10)
for _, job := range jobs {
    sem <- struct{}{}
    go func(j Job) {
        defer func() { <-sem }()
        process(j)
    }(job)
}

Gestione degli errori

Restituisca gli errori insieme ai risultati usando una struct dei risultati. Annulli il context al primo errore oppure raccolga tutti gli errori per un report finale.

type Result struct{ Val int; Err error }

Dimensionamento dinamico del pool

Per i pool adattivi, usi golang.org/x/sync/semaphore, che consente di acquisire e rilasciare una risorsa ponderata e supporta limiti dinamici alla concorrenza.

Worker pool rispetto a errgroup

golang.org/x/sync/errgroup fornisce un'API più semplice per avviare N goroutine e raccogliere il primo errore. Usi un pool quando ha bisogno di un insieme persistente di worker riutilizzabili.

Arresto ordinato

Chiuda il canale jobs per segnalare ai worker di terminare. Quando il WaitGroup ha terminato, chiuda results. Eventuali invii di lavori in sospeso devono avvenire prima di close(jobs).

Verifica rapida

Come segnala un worker pool ai worker di interrompere l'elaborazione?

Riepilogo: worker pool

Punti chiave:

N goroutine fisse leggono da un unico canale jobs
Chiuda il canale jobs per segnalare ai worker di terminare
WaitGroup tiene traccia del completamento; chiuda results al termine
Lavoro vincolato dalla CPU: dimensione del pool ≈ NumCPU; lavoro vincolato dall'I/O: dimensione maggiore

Domande Frequenti

La lezione «Modello del worker pool» è gratuita?

Sì — il testo completo di «Modello 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 «Modello del worker pool»?

Creare un worker pool di goroutine a dimensione fissa 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 4 di 4.

Quanto tempo richiede la lezione «Modello 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

← Torna a Go Academy