How do you handle signals in a Go application?

The correct way to process signals in Go applications is to use the os/signal package to monitor the signal and perform elegant shutdown. 1. Use signal.Notify to send SIGINT, SIGTERM and other signals to the channel; 2. Run the main service in goroutine and block the waiting signal; 3. After receiving the signal, perform elegant shutdown with timeout through context.WithTimeout; 4. Clean up resources such as closing database connections and stopping background goroutine; 5. Use signal.Reset to restore the default signal behavior when necessary to ensure that the program can be reliably terminated in Kubernetes and other environments.

Handling signals in a Go application is essential for graceful shutdowns, cleanup, and responding to OS-level events like SIGTERM , SIGINT , or SIGHUP . Go provides a clean and simple way to work with signals through the os/signal package.

Here's how you typically handle signals in Go:

1. Use signal.Notify to catch signals

The main approach is to set up a signal listener using signal.Notify , which sends incoming signals to a channel. This is usually done in a separate goroutine so it doesn't block your main application.

 package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    // Create a server (example with HTTP)
    server := &http.Server{Addr: ":8080"}

    // Set up signal channel
    stop := make(chan os.Signal, 1)
    signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM)

    // Start server in a goroutine
    go func() {
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("Server failed: %v", err)
        }
    }()

    fmt.Println("Server is running on :8080...")

    // Block until a signal is received
    <-stop
    fmt.Println("\nShutdown signal received.")

    // Gracefully shut down the server
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    if err := server.Shutdown(ctx); err != nil {
        log.Printf("Server shutdown error: %v", err)
    }

    fmt.Println("Server stopped gracefully.")
}

2. Common signals to handle

• syscall.SIGINT — Triggered by Ctrl C (interrupt).
• syscall.SIGTERM — Graceful termination signal (used by orchestration tools like Kubernetes).
• syscall.SIGHUP — Often used to reload config (common in daemons).

You can include multiple signals in signal.Notify :

 signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)

3. Graceful shutdown best practices

• Avoid os.Exit() unless absolutely necessary — it skips cleanup.
• Use context with timeout to limit how long shutdown can take.
• Close resources: database connections, file handles, network listeners.
• Stop background workers or goroutines using context cancellation.

Example of cleaning up background tasks:

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

// Simulate a background task
go func() {
    ticker := time.NewTicker(2 * time.Second)
    for {
        select {
        case <-ticker.C:
            fmt.Println("Working...")
        case <-ctx.Done():
            fmt.Println("Worker stopped.")
            Return
        }
    }
}()

// Later, on signal:
<-stop
cancel() // stop the worker

4. Don't forget to restore default behavior if needed

If you're building a long-running daemon or need to temporarily stop listening for signals, you can use signal.Reset() :

 defer signal.Reset(syscall.SIGINT, syscall.SIGTERM)

This restores the default signal behavior after your program exits.

Handling signals properly ensures your Go apps behave predictably in production environments — especially under container orchestration. The pattern is simple: listen on a channel, block until a signal arrives, then clean up and exit gracefully.

Basically: set up a channel, notify it of signals, wait, then shut down. Not complicated — but easy to overlook.

The above is the detailed content of How do you handle signals in a Go application?. For more information, please follow other related articles on the PHP Chinese website!