Go Academy · Aula

Desligamento normal

Pare os trabalhadores corretamente

Desligamento normal é 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.

Por que fazer um encerramento gracioso

É preciso informar às gorrotinas de longa duração quando devem parar. O encerramento gracioso permite que os workers terminem o trabalho atual, liberem recursos e saiam sem deixar vazamentos nem perder dados.

Nenhum vazamento de gorrotinas
Nenhuma escrita pela metade
Encerramento limpo do processo

O padrão do canal done

Uma abordagem clássica usa um canal done. Fechá-lo transmite um sinal de parada para todas as gorrotinas que o escutam, pois um canal fechado retorna imediatamente quando lido.

done := make(chan struct{})
// ... later
close(done)

select para sinais de parada

Um worker usa select para processar uma tarefa ou perceber o canal done. Quando done é fechado, esse caso é acionado e o worker retorna.

for {
    select {
    case <-done:
        return
    case j := <-jobs:
        process(j)
    }
}

context.Context

A ferramenta moderna idiomática é context. context.WithCancel fornece um contexto e uma função de cancelamento. Chamar cancel fecha o canal Done do contexto.

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

Escutando em ctx.Done()

Os workers usam select em ctx.Done(). Quando cancel é chamado ou um prazo expira, o canal é fechado e o worker sai.

select {
case <-ctx.Done():
    return ctx.Err()
case j := <-jobs:
    process(j)
}

Esperando pelos workers

Sinalizar a parada não é suficiente; você precisa esperar os workers realmente terminarem. Um sync.WaitGroup os acompanha para que main possa ficar bloqueado até que a contagem chegue a zero.

var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    runWorker(ctx)
}()
// ... later
cancel()
wg.Wait()

Limites de tempo com context

context.WithTimeout cancela automaticamente depois de uma duração. Isso limita por quanto tempo o encerramento pode demorar antes que você force a saída.

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

Um encerramento gracioso completo

Este programa executa dois workers, cancela o contexto e espera que ambos saiam corretamente antes de imprimir done.

package main

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

func worker(ctx context.Context, id int, wg *sync.WaitGroup) {
    defer wg.Done()
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("worker %d stopping\n", id)
            return
        case <-time.After(50 * time.Millisecond):
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    var wg sync.WaitGroup
    for i := 1; i <= 2; i++ {
        wg.Add(1)
        go worker(ctx, i, &wg)
    }
    time.Sleep(120 * time.Millisecond)
    cancel()
    wg.Wait()
    fmt.Println("all workers stopped")
}

Esgotando o trabalho em andamento

Durante o encerramento, muitas vezes você quer que os workers terminem o que já começaram. Leia as tarefas restantes em um loop final ou pare de aceitar novas tarefas enquanto permite que as atuais sejam concluídas.

Capturando sinais do OS

Em servidores reais, signal.NotifyContext associa o cancelamento a SIGINT e SIGTERM. Pressionar Ctrl+C aciona o mesmo caminho gracioso que um cancelamento manual.

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

Nunca se esqueça de cancel()

Sempre use defer cancel(), mesmo ao usar WithTimeout. Não chamar cancel deixa a gorrotina interna e o temporizador do contexto vazando até que o prazo expire.

Verificação rápida

Avalie seu conhecimento sobre encerramento.

Recapitulação

Você aprendeu sobre encerramento gracioso:

Use context.WithCancel ou um canal done para sinalizar a parada
Os workers usam select em ctx.Done()
WaitGroup garante que todos os workers realmente saiam
Associe o cancelamento a sinais do OS em servidores reais
Sempre use defer cancel()

Perguntas Frequentes

A aula “Desligamento normal” é grátis?

Sim — o texto completo de “Desligamento normal” é 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”?

Pare os trabalhadores 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”?

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