Patrón de grupo de trabajadores
Limite la concurrencia
Patrón de grupo de trabajadores es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 1 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 worker pool
Un worker pool inicia un número fijo de goroutines que extraen trabajos de un canal compartido. En lugar de iniciar una goroutine por tarea, inicia N workers y les proporciona trabajo.
- Limita el número de operaciones simultáneas
- Reutiliza goroutines en lugar de crear miles
- Protege recursos compartidos, como bases de datos o API
Por qué limitar la concurrencia
Un número ilimitado de goroutines puede agotar la memoria o los descriptores de archivo, o sobrecargar un servicio posterior. Un pool le proporciona un control para regular cuánto trabajo se ejecuta a la vez.
Si tiene que obtener 10000 URL, no querrá realizar 10000 solicitudes HTTP simultáneas. Un pool de 20 workers mantiene la situación bajo control.
El canal jobs
Los trabajos fluyen hacia un canal jobs. Cada worker los lee en un bucle for range. Cuando el canal se cierra, el bucle termina y el worker sale.
jobs := make(chan int, 100)
for j := 1; j <= 5; j++ {
jobs <- j
}
close(jobs)Un solo worker
Un worker no es más que una función que recorre el canal de trabajos. Procesa cada trabajo y escribe el resultado en un canal de resultados.
func worker(id int, jobs <-chan int, results chan<- int) {
for j := range jobs {
results <- j * 2
}
}Iniciar varios workers
Inicie el pool con un bucle sencillo. Cada iteración inicia una goroutine que ejecuta la misma función de worker. Todas comparten los mismos canales de trabajos y resultados.
for w := 1; w <= 3; w++ {
go worker(w, jobs, results)
}Tipos de canal direccionales
Observe <-chan int, que solo permite recibir, y chan<- int, que solo permite enviar, en la firma del worker. Estos tipos direccionales permiten que el compilador impida que un worker envíe accidentalmente a jobs o lea de results.
Recopilar resultados
Después de proporcionar todos los trabajos y cerrar el canal, la goroutine principal lee exactamente tantos resultados como trabajos había. Esto sincroniza el programa para que no termine antes de tiempo.
sum := 0
for a := 1; a <= 5; a++ {
sum += <-results
}
fmt.Println("total:", sum)Un pool completo y ejecutable
Aquí tiene el patrón completo en un solo programa: tres workers duplican cinco números. Ejecútelo y observe el total.
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 búfer frente a sin búfer
Un canal de trabajos con búfer permite que el productor ponga trabajos en cola sin bloquearse hasta que el búfer se llene. Un canal sin búfer fuerza una entrega directa: el envío se bloquea hasta que un worker está preparado. El búfer suaviza los picos de producción.
Elegir el tamaño del pool
Para tareas limitadas por la CPU, establezca el tamaño del pool cerca de runtime.NumCPU(). Para tareas limitadas por la E/S, como las de red o disco, puede usar un número mucho mayor, ya que los workers pasan tiempo esperando en lugar de calculando.
package main
import (
"fmt"
"runtime"
)
func main() {
fmt.Println("CPUs:", runtime.NumCPU())
}Evitar fugas de goroutines
Si olvida hacer close(jobs), los workers se bloquearán para siempre en un canal vacío y se producirá una fuga. Cierre siempre el canal jobs cuando haya enviado todo el trabajo para que terminen los bucles for range.
Comprobación rápida
Compruebe cuánto entiende de los grupos de workers.
Recapitulación
Ha aprendido el patrón de grupo de workers:
- Iniciar un número fijo de workers que lean de un canal de trabajos compartido
- Usar tipos de canal direccionales para mayor seguridad
- Cerrar el canal de trabajos para finalizar los workers
- Recopilar los resultados para sincronizar la finalización
- Dimensionar el grupo según el tipo de carga de trabajo (CPU o E/S)
Preguntas frecuentes
¿La lección «Patrón de grupo de trabajadores» es gratis?
Sí — el texto completo de «Patrón de grupo de trabajadores» 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 grupo de trabajadores»?
Limite la concurrencia 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 1 de 4.
¿Cuánto tiempo toma la lección «Patrón de grupo de trabajadores»?
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
- Patrón de grupo de trabajadores
- Fan-Out y Fan-In
- Etapas de pipeline
- Cierre ordenado