Use signal.Notify() in the os/signal package to register the specified signal (such as SIGINT, SIGTERM) to the buffer channel, so that the program can capture rather than terminate by default; 2. Wait for the signal to arrive through

Handling signals in Go is essential when you want your program to respond gracefully to OS-level events like SIGTERM , SIGINT , or SIGHUP . For example, you might want to clean up resources, close files, or shut down a server properly when a user presses Ctrl C .

Let's go through a practical example to show how signal handling works in Go.

?? Basic Signal Handling in Go

Here's a simple Go program that listens for interrupt signals and shuts down gracefully:

 package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    // Create a channel to receive OS signals
    sigChan := make(chan os.Signal, 1)

    // Notify the channel of specific signals
    signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)

    fmt.Println("Server started... (press Ctrl C to stop)")

    // Simulate work in the background
    go func() {
        for {
            fmt.Println("Working...")
            time.Sleep(2 * time.Second)
        }
    }()

    // Block until a signal is received
    sig := <-sigChan
    fmt.Printf("\nReceived signal: %v\n", sig)

    // Perform cleanup
    fmt.Println("Cleaning up resources...")
    time.Sleep(1 * time.Second) // Simulate cleanup
    fmt.Println("Shutdown complete.")
}

? What's Happening?

• signal.Notify(sigChan, ...) tells Go to send the specified signals to sigChan instead of letting them terminate the program immediately.
• os.Interrupt corresponds to Ctrl C ( SIGINT ).
• syscall.SIGTERM is the standard termination signal (used by tools like kill ).
• The program runs a background goroutine simulating work.
• <-sigChan blocks execution until a signal arrives.
• Once a signal is received, we handle cleanup before exiting.

? Graceful Shutdown with HTTP Server

A common real-world use case is gracefully shutting down an HTTP server:

 package main

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

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        time.Sleep(5 * time.Second) // Simulate long-running request
        w.Write([]byte("Hello, world!"))
    })

    server := &http.Server{
        Addr: ":8080",
        Handler: mux,
    }

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

    // Set up signal handling
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)

    // Wait for interrupt signal
    <-sigChan
    fmt.Println("\nShutting down server...")

    // Create a deadline to wait for graceful shutdown
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    // Attempt graceful shutdown
    if err := server.Shutdown(ctx); err != nil {
        log.Printf("Server forced to shutdown: %v", err)
    } else {
        fmt.Println("Server stopped gracefully.")
    }
}

? Key Points

• Always use signal.Notify() with a buffered channel (size 1 is enough).
• Use context.WithTimeout() to avoid hanging during shutdown.
• Call server.Shutdown() to stop the HTTP server gracefully—this stops new connections and give active requests time to finish.
• Handle both os.Interrupt (Ctrl C) and syscall.SIGTERM (used in production environments like Docker/Kubernetes).

? Supported Signals (Common Ones)

Note: SIGKILL and SIGSTOP cannot be caught or ignored.

? Pro Tip: Reload Config with SIGHUP

You can use SIGHUP to trigger config reloads (common in daemons):

 signal.Notify(sigChan, syscall.SIGHUP)

go func() {
    for {
        sig := <-sigChan
        if sig == syscall.SIGHUP {
            fmt.Println("Reloading config...")
            // Reload your config file here
        }
    }
}()

Handling signals in Go is straightforward with the os/signal package. Whether you're building a CLI tool, a daemon, or a web server, proper signal handling ensures your app behaves predictably and cleans up properly.

Basically, just set up a channel, notify it of the signals you care about, and react when they arrive.

The above is the detailed content of how to handle signals go by example. For more information, please follow other related articles on the PHP Chinese website!