理解操作系统的信号机制：从Ctrl+C到优雅停止

前言

如果你在 Linux 或 macOS 终端里运行过一个长时间执行的程序，大概率会用过 Ctrl+C 来“强制”结束它。这个看似简单的操作背后，其实是操作系统信号（Signal）机制在起作用。

信号不仅是用户与进程交互的桥梁，也是进程间通信、系统管理的重要手段。比如，当我们用 kill 命令结束一个进程时，实际上就是向目标进程发送了一个信号；而像 Nginx、Redis 这样的服务程序，往往都支持通过接收特定信号来重新加载配置、优雅停止等高级功能。

什么是信号？

信号的定义

信号是一种异步通知机制，由操作系统内核（或另一个进程）发送给某个进程，告知其某个事件已经发生。收到信号的进程可以采取三种处理方式之一：

执行默认动作 – 大多数信号都有默认行为，例如终止进程、忽略信号、暂停进程等。
忽略信号 – 进程可以显式地告诉内核“我不想处理这个信号”。
捕获信号 – 进程可以注册一个信号处理函数（signal handler），当信号到来时，由该函数自定义处理逻辑。

信号的来源

信号可以由多种事件触发：

硬件异常：例如除零错误（SIGFPE）、非法内存访问（SIGSEGV）。
终端交互：例如按下 Ctrl+C（SIGINT）、Ctrl+\（SIGQUIT）。
软件事件：例如定时器到期（SIGALRM）、子进程退出（SIGCHLD）。
其他进程：通过 kill() 系统调用发送信号。

信号的分类

按照行为，信号可以分为两大类：

不可靠信号（非实时信号）：编号 1~31（在 Linux 中），不支持排队，可能丢失。
可靠信号（实时信号）：编号 34~64，支持排队，不会丢失。

我们日常接触的大多数信号都属于不可靠信号，但它们的“不可靠”主要体现在早期 UNIX 实现上，现代操作系统已经做了很多改进。

信号的产生与处理

信号产生

当内核检测到某个事件满足发送信号的条件时，就会在目标进程的信号位图中标记对应的信号。如果进程正处于可中断的睡眠状态，内核会将其唤醒，使其有机会立即处理信号。

信号处理

进程处理信号的时机是在从内核态返回用户态之前。内核会检查进程的待处理信号，并按照以下优先级决定如何处理：

若信号被忽略，则直接清除标记。
若信号被捕获，则调用用户注册的信号处理函数（在用户态执行）。
否则，执行该信号的默认动作。

需要注意的是，信号处理函数执行期间，同一个信号可能会被自动阻塞，防止重入。这也是编写信号处理函数时要特别小心的地方。

常见信号及其含义

下表列出了我们在编程和系统管理中经常遇到的信号（基于 Linux 标准）：

信号名	编号	默认动作	说明
SIGHUP	1	终止进程	终端挂断信号，也常用于通知守护进程重新加载配置。
SIGINT	2	终止进程	终端中断信号，通常由 Ctrl+C 产生。
SIGQUIT	3	终止并生成 core 文件	终端退出信号，通常由 Ctrl+\ 产生。
SIGILL	4	终止并生成 core 文件	非法指令信号，通常由执行了非法 CPU 指令引起。
SIGTRAP	5	终止并生成 core 文件	跟踪/断点陷阱信号，由调试器使用。
SIGABRT	6	终止并生成 core 文件	程序调用 `abort()` 时产生，用于异常终止。
SIGBUS	7	终止并生成 core 文件	总线错误信号，通常由内存地址对齐错误引起。
SIGFPE	8	终止并生成 core 文件	浮点异常信号，例如除零错误。
SIGKILL	9	终止进程（不可捕获）	强制杀死信号，进程无法忽略或捕获，常用于“杀不掉”的进程。
SIGUSR1	10	终止进程	用户自定义信号 1，常用于进程间自定义通信。
SIGSEGV	11	终止并生成 core 文件	段错误信号，通常由非法内存访问（如空指针解引用）引起。
SIGUSR2	12	终止进程	用户自定义信号 2。
SIGPIPE	13	终止进程	管道破裂信号，当向一个已关闭的管道写数据时产生。
SIGALRM	14	终止进程	定时器信号，由 `alarm()` 或 `setitimer()` 设置的定时器到期时产生。
SIGTERM	15	终止进程	优雅终止信号，`kill` 命令默认发送的就是它。
SIGSTKFLT	16	终止进程	协处理器栈错误（已废弃，现代 Linux 中很少见）。
SIGCHLD	17	忽略	子进程状态改变（停止、退出）时发送给父进程。
SIGCONT	18	继续进程	让一个被暂停的进程继续执行。
SIGSTOP	19	暂停进程（不可捕获）	暂停进程执行，直到收到 SIGCONT。
SIGTSTP	20	暂停进程	终端暂停信号，通常由 Ctrl+Z 产生。
SIGTTIN	21	暂停进程	后台进程尝试读取终端时产生。
SIGTTOU	22	暂停进程	后台进程尝试写入终端时产生。
SIGURG	23	忽略	紧急数据到达（如带外数据）。
SIGXCPU	24	终止并生成 core 文件	进程超过 CPU 时间限制。
SIGXFSZ	25	终止并生成 core 文件	文件大小超过限制。
SIGVTALRM	26	终止进程	虚拟定时器信号（由 `setitimer(ITIMER_VIRTUAL)` 产生）。
SIGPROF	27	终止进程	性能分析定时器信号（由 `setitimer(ITIMER_PROF)` 产生）。
SIGWINCH	28	忽略	终端窗口大小改变时产生。
SIGIO / SIGPOLL	29	终止进程	异步 I/O 事件（文件描述符可读/可写等）。
SIGPWR	30	终止进程	电源故障信号（常用于 UPS 电池电量低）。
SIGSYS	31	终止并生成 core 文件	系统调用参数错误（如错误的系统调用号）。

注：
SIGKILL 和 SIGSTOP 是两个特殊的信号，它们不能被捕获、忽略或阻塞，这是为了给系统管理员一个最终的控制手段。
大多数以“终止并生成 core 文件”为默认动作的信号，都会在进程终止时生成一个 core dump 文件，用于调试。
信号编号可能因操作系统和架构略有差异，上表以 Linux x86_64 为准。

信号在编程中的应用：Go 语言示例

Go 语言的标准库 os/signal 提供了对信号的封装，让我们能够方便地捕获和处理信号。下面我们通过一个简单的 HTTP 服务器示例，演示如何实现优雅停止（Graceful Shutdown）。

场景描述

假设我们有一个 HTTP 服务，它正在处理一些请求。如果直接按下 Ctrl+C（发送 SIGINT），服务会立即退出，可能导致正在处理的请求被中断，数据不一致。更好的做法是：捕获 SIGINT 或 SIGTERM 信号，先停止接受新请求，等待已有请求处理完毕，再退出。

代码实现

package main

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

func main() {
    // 创建一个 HTTP 服务器
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        time.Sleep(5 * time.Second) // 模拟一个耗时操作
        fmt.Fprintf(w, "Hello, signal!\n")
    })

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

    // 启动服务器
    go func() {
        log.Println("Server starting on :8080")
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("ListenAndServe error: %v", err)
        }
    }()

    // 等待中断信号
    quit := make(chan os.Signal, 1)
    // 捕获 SIGINT 和 SIGTERM 信号
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    sig := <-quit
    log.Printf("Received signal: %v\n", sig)

    // 优雅关闭：给服务器 30 秒时间完成现有请求
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    if err := srv.Shutdown(ctx); err != nil {
        log.Fatalf("Server forced to shutdown: %v", err)
    }

    log.Println("Server exited gracefully")
}

代码解析

启动服务器：在一个单独的 goroutine 中启动 HTTP 服务，主 goroutine 继续执行。
信号通道：创建一个缓冲为 1 的 channel quit，用于接收信号。
注册信号：signal.Notify 将 SIGINT 和 SIGTERM 信号转发到 quit 通道。
阻塞等待：<-quit 会一直阻塞，直到收到其中一个信号。
优雅关闭：调用 srv.Shutdown(ctx)，该方法会停止接受新请求，并等待所有正在处理的请求完成（或超时）。
超时控制：通过 context.WithTimeout 设置一个 30 秒的超时，防止某些请求一直不结束导致服务无法退出。

运行效果

编译并运行程序：
1
go run main.go
访问 http://localhost:8080/，此时请求会等待 5 秒才返回。
在请求未返回时，按下 Ctrl+C，你会看到类似下面的输出：
1
2
Received signal: interrupt
Server exited gracefully
服务器不会立即退出，而是会等待正在处理的请求完成（最多等 30 秒），然后才退出。

总结

信号机制是操作系统提供的一种简洁而强大的进程间通信方式。从最常用的 Ctrl+C 中断，到服务程序的优雅停止、配置重载，信号都在其中扮演着关键角色。

理解信号的产生、处理以及编程中的捕获方法，能让我们写出更健壮、更友好的程序。Go 语言通过 os/signal 包将信号封装成了 channel，使得异步信号处理变得异常简单，这也是 Go 在并发编程中一个非常优雅的设计。

当然，信号只是进程间通信的其中一种手段，还有管道、消息队列、共享内存等多种方式。每种方式都有其适用场景，选择合适的技术才能让我们的系统更加稳定高效。

希望这篇博客能帮助你更好地理解信号机制，并在实际开发中用好它。如果你有任何疑问或补充，欢迎在评论区留言讨论。

Kaku的个人博客