使用os/signal包中的signal.Notify()將指定信號(hào)（如SIGINT、SIGTERM）註冊到緩衝通道，使程序能捕獲而非默認(rèn)終止；2. 通過

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 gives 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.

以上是如何處理信號(hào)以身作則的詳細(xì)內(nèi)容。更多資訊請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！