0Pricing
Go Academy · Lección

Detección de fugas y cancelación

Garantía de salida de las goroutines y prevención de fugas

Detección de fugas y cancelación 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 una fuga de goroutine?

Una fuga de goroutine ocurre cuando una goroutine se inicia, pero nunca termina. Las goroutines filtradas se acumulan con el tiempo y consumen memoria de pila y CPU hasta que se finaliza el proceso.

Fuga común: recepción bloqueada en un canal

Una goroutine que espera una recepción en un canal que nunca recibe un valor se bloquea para siempre:

go func() {
    v := <-ch // leaks if no sender and ch is never closed
    use(v)
}()

Fuga común: no hay señal done

Una goroutine dentro de un bucle for sin condición de salida ni canal done se ejecuta para siempre:

go func() {
    for {
        work()
        // no exit condition — leaks
    }
}()

Detección de fugas con goleak

go.uber.org/goleak verifica que no haya goroutines filtradas al final de una prueba:

func TestMyFunc(t *testing.T) {
    defer goleak.VerifyNone(t)
    myFunc() // should not leak goroutines
}

El contexto como solución

La forma idiomática de detener goroutines de larga duración es utilizar un contexto. Pase ctx a la goroutine y seleccione mediante ctx.Done().

go func(ctx context.Context) {
    for {
        select {
        case work := <-workCh:
            process(work)
        case <-ctx.Done():
            return // clean exit
        }
    }
}(ctx)

Patrón del canal done

Para casos más sencillos sin contexto, utilice un canal done dedicado. Ciérrelo para transmitir la señal de detención a todas las goroutines que leen de él.

done := make(chan struct{})
go func() {
    select {
    case v := <-data: use(v)
    case <-done: return
    }
}()
close(done) // stops goroutine

Detección con runtime

Imprima el número de goroutines para detectar su crecimiento durante la ejecución:

fmt.Println("goroutines:", runtime.NumGoroutine())

Goroutines del servidor HTTP

net/http gestiona automáticamente las goroutines por solicitud y las limpia cuando finaliza la solicitud. Sin embargo, los controladores que inician goroutines sin encargarse de su limpieza aún pueden provocar fugas.

Pruebas para detectar fugas

Ejecute el conjunto de pruebas con goleak como TestMain o mediante un defer por prueba. Cualquier goroutine que no haya terminado después del cuerpo de la prueba provoca un fallo de esta.

func TestMain(m *testing.M) {
    goleak.VerifyTestMain(m)
}

Fugas causadas por time.After

time.After dentro de un select en un bucle crea un temporizador nuevo en cada iteración, que no puede ser recopilado por el GC hasta que se activa. Sustitúyalo por time.NewTimer y Reset.

Fuga causada por una goroutine que devuelve un error

Si se supone que una goroutine debe enviar un resultado a través de un canal, pero devuelve el control antes de tiempo debido a un error sin enviar nada, la goroutine consumidora se bloquea para siempre. Envíe siempre un valor o cierre el canal en todas las rutas.

Comprobación rápida

¿Cuál es la forma más idiomática de detener una goroutine de larga duración en Go?

Resumen: detección de fugas y cancelación

Puntos clave:

  • Las fugas de goroutines se acumulan; supervíselas con runtime.NumGoroutine()
  • goleak detecta automáticamente las fugas de goroutines en las pruebas
  • Proporcione siempre a las goroutines una ruta de salida: un contexto, un canal done o una entrada cerrada
  • time.After provoca fugas de temporizadores en los bucles; utilice NewTimer+Reset

Preguntas frecuentes

¿La lección «Detección de fugas y cancelación» es gratis?

Sí — el texto completo de «Detección de fugas y cancelación» 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 «Detección de fugas y cancelación»?

Garantía de salida de las goroutines y prevención de fugas 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 «Detección de fugas y cancelación»?

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

  1. Patrones de pipelines y etapas
  2. errgroup para gestionar errores concurrentes
  3. Patrón de semáforo
  4. Detección de fugas y cancelación
← Volver a Go Academy