Go Academy · Lección

Cierre ordenado de tareas

Detenga las tareas correctamente

Cierre ordenado de tareas 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.

Detener trabajos correctamente

Un planificador que se detiene en mitad de un trabajo puede dañar los datos o dejar tareas a medio terminar. Un apagado correcto significa: dejar de aceptar ejecuciones nuevas, permitir que terminen los trabajos en curso (hasta alcanzar un plazo límite) y salir después.

Escuchar señales

Capture señales del sistema operativo, como SIGINT (Ctrl+C) y SIGTERM (detención del orquestador), para poder apagar el sistema de forma intencionada.

sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
<-sig
fmt.Println("shutting down")

signal.NotifyContext

Go 1.16+ ofrece un práctico ayudante que cancela un contexto cuando llega una señal.

ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
defer stop()
<-ctx.Done()

Detener el planificador

Con robfig/cron, c.Stop() devuelve un contexto que finaliza cuando se completan todos los trabajos en ejecución. Espere a que termine para vaciarlos.

ctx := c.Stop()        // stops scheduling, returns ctx
<-ctx.Done()            // wait for running jobs
fmt.Println("all jobs finished")

Propagar la cancelación a los trabajos

Pase un contexto a cada trabajo para que las tareas de larga duración puedan cancelarse rápidamente cuando comience el apagado.

func job(ctx context.Context) {
    select {
    case <-time.After(time.Hour):
    case <-ctx.Done():
        return // bail out early
    }
}

Limitar la espera

No espere indefinidamente a trabajos bloqueados. Use un contexto con tiempo de espera para que el apagado termine incluso si un trabajo se queda bloqueado.

shutCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()

WaitGroups para planificadores personalizados

Si crea su propio planificador con goroutines, realice su seguimiento con un sync.WaitGroup y use Wait() durante el apagado.

var wg sync.WaitGroup
wg.Add(1)
go func() { defer wg.Done(); doWork() }()
// shutdown:
wg.Wait()

Evitar iniciar trabajos nuevos

Una vez que comienza el apagado, el ticker o cron debe dejar de activarse. Cerrar un canal de finalización o cancelar el contexto garantiza que el bucle detecte la señal y deje de programar ejecuciones nuevas.

La idempotencia es útil

Diseñe los trabajos para que sea seguro volver a ejecutarlos. Si un trabajo se detiene a mitad de camino y se reintenta después del reinicio, la lógica idempotente evita efectos duplicados (correos electrónicos duplicados, cobros duplicados).

El patrón completo

En conjunto: un contexto que notifica las señales, un Stop de cron que devuelve un contexto de vaciado y un tiempo de espera limitado. Este es el esquema estándar de apagado correcto para servicios programados.

Ejecutable: detención correcta con contexto

Este programa autónomo ejecuta un proceso periódico y lo detiene correctamente mediante la cancelación del contexto, esperando a que termine el tic en curso.

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        t := time.NewTicker(5 * time.Millisecond)
        defer t.Stop()
        for {
            select {
            case <-t.C:
                fmt.Println("working")
            case <-ctx.Done():
                fmt.Println("stopping cleanly")
                return
            }
        }
    }()
    time.Sleep(17 * time.Millisecond)
    cancel()   // signal shutdown
    wg.Wait()  // wait for worker to finish
    fmt.Println("shutdown complete")
}

Comprobación rápida

Compruebe sus conocimientos sobre la detención correcta de trabajos.

Resumen

Ha aprendido a detener trabajos correctamente:

Capture SIGINT/SIGTERM, idealmente mediante signal.NotifyContext
cron.Stop() devuelve un contexto que espera a que terminen los trabajos en ejecución
Propague el contexto a los trabajos y limite la espera con un tiempo de espera
Haga que los trabajos sean idempotentes para que los reintentos sean seguros

Preguntas frecuentes

¿La lección «Cierre ordenado de tareas» es gratis?

Sí — el texto completo de «Cierre ordenado de tareas» 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 «Cierre ordenado de tareas»?

Detenga las tareas correctamente 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 «Cierre ordenado de tareas»?

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