errgroup para gestionar errores concurrentes
Uso práctico de golang.org/x/sync/errgroup
errgroup para gestionar errores concurrentes es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 2 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.
Problema de las goroutines y los errores
Al lanzar goroutines con go func() se descartan los valores devueltos, incluidos los errores. Necesita mecanismos adicionales (canales, WaitGroup) para recopilarlos. errgroup simplifica esta tarea.
golang.org/x/sync/errgroup
errgroup.Group ejecuta goroutines y recopila errores. Wait() bloquea hasta que terminan todas las goroutines y devuelve el primer error distinto de nil.
var g errgroup.Group
g.Go(func() error { return fetchUsers() })
g.Go(func() error { return fetchOrders() })
if err := g.Wait(); err != nil {
log.Fatal(err)
}errgroup.WithContext
WithContext devuelve un grupo y un context derivado. El context se cancela cuando la primera goroutine devuelve un error, lo que detiene el trabajo restante.
g, ctx := errgroup.WithContext(context.Background())
g.Go(func() error { return doWork(ctx) })
g.Go(func() error { return doOtherWork(ctx) })
err := g.Wait()Recopilación de resultados junto con errores
errgroup no recopila resultados, solo errores. Capture los resultados en slices preasignados, accedidos mediante un índice, para evitar la sincronización:
results := make([]Result, len(items))
for i, item := range items {
i, item := i, item
g.Go(func() error {
r, err := process(ctx, item)
if err != nil { return err }
results[i] = r
return nil
})
}
if err := g.Wait(); err != nil { return err }g.SetLimit (Go 1.20 o posterior)
g.SetLimit(n) limita el número de goroutines que se ejecutan simultáneamente; actúa como un semáforo integrado sin necesidad de un canal independiente.
g.SetLimit(10) // at most 10 goroutines at once
for _, item := range items {
g.Go(func() error { return process(item) })
}g.TryGo
g.TryGo(f) inicia la goroutine solo si el límite (establecido mediante SetLimit) lo permite. Devuelve false si no se inicia.
Solo se devuelve el primer error
errgroup solo devuelve el primer error. Si necesita todos los errores, recopílelos en un slice protegido por un mutex dentro de cada goroutine.
var mu sync.Mutex
var errs []error
g.Go(func() error {
if err := doWork(); err != nil {
mu.Lock(); errs = append(errs, err); mu.Unlock()
}
return nil
})Diferencia con sync.WaitGroup
WaitGroup realiza un seguimiento de la finalización; errgroup realiza un seguimiento de la finalización y además recopila errores. Prefiera errgroup cuando deba notificarse el fallo de cualquier goroutine.
Propagación de la cancelación del context
Cuando se utiliza errgroup.WithContext, la cancelación del context derivado indica a todas las demás goroutines que deben detenerse, siguiendo una semántica similar a cancelar ante el primer error.
Pruebas de código con errgroup
En las pruebas, inyecte un context con WithTimeout para asegurarse de que el grupo no se ejecute indefinidamente si una goroutine se bloquea.
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
g, ctx := errgroup.WithContext(ctx)Alternativa con semáforo
Antes de SetLimit (Go < 1.20), utilice un canal con búfer como semáforo dentro de las goroutines individuales para conseguir el mismo efecto.
Comprobación rápida
¿Qué devuelve errgroup.WithContext que no devuelve un errgroup.Group normal?
Resumen: errgroup
Puntos clave:
- g.Go(func() error): lanza una goroutine y recopila el primer error
- g.Wait(): bloquea hasta que todas terminan; devuelve el primer error
- WithContext: el context se cancela ante el primer error
- g.SetLimit(n): limita las goroutines simultáneas (Go 1.20 o posterior)
Preguntas frecuentes
¿La lección «errgroup para gestionar errores concurrentes» es gratis?
Sí — el texto completo de «errgroup para gestionar errores concurrentes» 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 «errgroup para gestionar errores concurrentes»?
Uso práctico de golang.org/x/sync/errgroup 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 2 de 4.
¿Cuánto tiempo toma la lección «errgroup para gestionar errores concurrentes»?
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
- Patrones de pipelines y etapas
- errgroup para gestionar errores concurrentes
- Patrón de semáforo
- Detección de fugas y cancelación