Go Academy · Lección

Patrón de pool de workers

Creación de un pool de workers de goroutines de tamaño fijo

Patrón de pool de workers es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

¿Qué es un grupo de workers?

Un grupo de workers crea por adelantado un número fijo de goroutines que procesan trabajos de una cola compartida. Esto limita la concurrencia y evita el agotamiento de recursos debido a la creación ilimitada de goroutines.

Implementación básica

Cree un canal de trabajos y N goroutines que lean de él:

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

Envío de trabajos

Envíe todos los trabajos al canal y, después, ciérrelo. Los workers procesarán todos los trabajos y saldrán de sus bucles range cuando el canal se cierre.

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

Recopilación de resultados

Lea los resultados simultáneamente mientras envía los trabajos. Utilice una goroutine para el grupo, de modo que la recopilación de resultados no provoque un interbloqueo con el envío de trabajos.

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

Ajuste del tamaño del grupo

Para trabajos limitados por la CPU, establezca el tamaño del grupo en runtime.NumCPU(). Para trabajos limitados por E/S, un multiplicador mayor (por ejemplo, 10×) aprovecha mejor el tiempo de espera. Realice perfiles para encontrar el punto óptimo.

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

Añadir cancelación mediante contexto

Pase un contexto a los workers para que se detengan antes si se cancela:

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

Alternativa con semáforo

En lugar de un grupo fijo de goroutines, utilice un canal con búfer como semáforo para limitar el número de goroutines que se ejecutan simultáneamente, sin dejar de crear una por trabajo.

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

Gestión de errores

Devuelva los errores junto con los resultados mediante una estructura de resultados. Cancele el contexto ante el primer error o recopile todos los errores para elaborar un informe final.

type Result struct{ Val int; Err error }

Ajuste dinámico del tamaño del grupo

Para grupos adaptativos, utilice golang.org/x/sync/semaphore, que permite adquirir y liberar un recurso ponderado y admite límites de concurrencia dinámicos.

Grupo de workers frente a errgroup

golang.org/x/sync/errgroup proporciona una API más sencilla para iniciar N goroutines y recopilar el primer error. Utilice un grupo de workers cuando necesite un conjunto persistente de workers reutilizables.

Cierre ordenado

Cierre el canal de trabajos para indicar a los workers que se detengan. Cuando termine el WaitGroup, cierre results. Cualquier envío de trabajos pendiente debe realizarse antes de close(jobs).

Comprobación rápida

¿Cómo indica un grupo de workers a los workers que deben dejar de procesar?

Repaso: grupo de workers

Puntos clave:

N goroutines fijas leen de un canal de trabajos
Cierre el canal de trabajos para indicar a los workers que terminen
WaitGroup registra la finalización; cierre results cuando terminen
Trabajos limitados por CPU: tamaño del grupo ≈ NumCPU; limitados por E/S: mayor

Preguntas frecuentes

¿La lección «Patrón de pool de workers» es gratis?

Sí — el texto completo de «Patrón de pool de workers» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Patrón de pool de workers»?

Creación de un pool de workers de goroutines de tamaño fijo Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Patrón de pool de workers»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Go Academy