Go Academy · Aula

Desligamento normal de tarefas

Pare tarefas corretamente

Desligamento normal de tarefas é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Parando tarefas corretamente

Um agendador encerrado no meio de um job pode corromper dados ou deixar trabalho parcialmente concluído. Encerramento gradual significa: parar de aceitar novas execuções, permitir que os jobs em andamento terminem (até um prazo limite) e então sair.

Escutando sinais

Capture sinais do sistema operacional, como SIGINT (Ctrl+C) e SIGTERM (parada do orquestrador), para poder encerrar o programa de propósito.

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

signal.NotifyContext

O Go 1.16+ oferece um auxiliar prático que cancela um contexto quando um sinal chega.

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

Parando o agendador

Com robfig/cron, c.Stop() retorna um contexto que é concluído quando todos os jobs em execução terminam. Aguarde esse contexto para permitir que eles terminem.

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

Propagando o cancelamento para os jobs

Passe um contexto para cada job para que trabalhos longos possam ser interrompidos rapidamente quando o encerramento começar.

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

Limitando a espera

Não espere indefinidamente por jobs travados. Use um contexto com tempo limite para que o encerramento seja concluído mesmo que um job trave.

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

WaitGroups para agendadores personalizados

Se você criar seu próprio agendador com rotinas Go, acompanhe-as com um sync.WaitGroup e use Wait() durante o encerramento.

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

Evite iniciar trabalho novo

Quando o encerramento começar, o marcador periódico/cron deverá parar de ser acionado. Fechar um canal de conclusão ou cancelar o contexto garante que o laço veja o sinal e pare de agendar novas execuções.

A idempotência ajuda

Projete os jobs para que seja seguro executá-los novamente. Se um job for encerrado no meio do caminho e repetido após a reinicialização, uma lógica idempotente evitará efeitos duplicados (e-mails duplicados, cobranças duplicadas).

O padrão completo

Reunindo tudo: um contexto que notifica quando chega um sinal, um Stop do cron que retorna um contexto de drenagem e um tempo limite definido. Esse é o esqueleto padrão de encerramento gradual para serviços agendados.

Executável: encerramento gradual com contexto

Este programa independente executa um trabalhador periódico e o encerra corretamente por meio do cancelamento do contexto, aguardando a conclusão do pulso em andamento.

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

Verificação rápida

Teste sua compreensão do encerramento gradual de jobs.

Recapitulação

Você aprendeu sobre o encerramento gradual de jobs:

Capture SIGINT/SIGTERM, de preferência por meio de signal.NotifyContext
cron.Stop() retorna um contexto que permite a conclusão dos jobs em execução
Propague o contexto para os jobs e limite a espera com um tempo limite
Torne os jobs idempotentes para que as repetições sejam seguras

Perguntas Frequentes

A aula “Desligamento normal de tarefas” é grátis?

Sim — o texto completo de “Desligamento normal de tarefas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Desligamento normal de tarefas”?

Pare tarefas corretamente Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Desligamento normal de tarefas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy