Linux 信号捕捉与处理机制

这里真正要盯住的是 sa_handler 和 sa_mask。

信号处理函数执行时，当前信号默认会被临时加入信号屏蔽字，避免自己把自己反复打断。这个设计挺实用，尤其是那些处理过程不长，但不希望被同类信号打乱的场景。如果还想额外屏蔽其他信号，就把它们放进 sa_mask。

#include <iostream>
#include <signal.h>
#include <cstring>
#include <unistd.h>

using namespace std;

void PrintPending() {
    sigset_t set; // 将当前被阻塞且处于未决状态的信号集存储到 set 信号集中（输出型参数）
    sigpending(&set); // 打印 set 位图（即 pending 位图）
    for (int signo = 31; signo >= 1; signo--) {
        if (sigismember(&set, signo)) cout << "1";
        else cout << "0";
    }
    cout << endl;
}

void handler(int signo) {
    // 收到 2 号信号打印一句收到了，然后循环调用 PrintPending
    cout << "catch a signal, signal number : " << signo << endl;
    while (true) {
        PrintPending();
        sleep(1);
    }
}

int main() {
    // 创建并初始化 act 和 oact
    struct sigaction act, oact;
    memset(&act, 0, sizeof(act));
    memset(&oact, 0, sizeof(oact));
    
    // 设置 sa_mask 为全 0
    sigemptyset(&act.sa_mask);
    // 设置信号屏蔽
    sigaddset(&act.sa_mask, 1);
    sigaddset(&act.sa_mask, 3);
    sigaddset(&act.sa_mask, 4);
    
    // 设置信号处理函数为 handler
    act.sa_handler = handler; // SIG_IGN SIG_DFL
    // 需要处理的就是 2 号信号
    sigaction(2, &act, &oact);
    
    while (true) {
        cout << "I am a process: " << getpid() << endl;
        sleep(1);
    }
    return 0;
}

正常情况下没什么特别的，pending 位图就是全 0。收到 2 号信号后，程序进入 handler，开始打印 pending。这时如果再发 1、2、3、4 号信号，1 号信号本来就是终止信号，3 和 4 又被放进了 sa_mask，所以它们不会立刻打断当前处理流程，而是先被挂起。

四、几个容易踩坑的点

1. 可重入函数

看一个很典型的头插例子：

insert(struct Node* node) {
    node->next = head;
    head = node;
}

如果 node1->next = head; 执行完了，还没来得及执行 head = node1;，这时候来了一个信号，handler 里又调用了一次 insert(&node2)：

void handler(int signo) {
    insert(&node2);
}

insert(struct Node* node) {
    node->next = head;
    head = node;
}

那执行顺序就可能变成这样：

node1->next = head;
node2->next = head;
head = &node2;
head = &node1;

结果很直接，node2 被挂丢了，单链表断了一截。这类函数如果允许被重复进入，而且重复进入后可能破坏状态，就叫不可重入函数。带共享指针、静态变量、全局状态的代码，通常都得默认按这个风险去看，别想当然。

2. volatile

volatile 的作用没那么神秘，它只是告诉编译器：这个变量随时可能被外部改变，别把它优化得太激进。

程序在收到 2 号信号之前一直在 while 里空转。信号处理函数把 flag 置成 1 之后，理论上主循环应该看到变化然后退出；但如果编译器把 flag 缓存在寄存器里，循环每次判断读到的可能还是旧值，看起来就像程序没反应。

这里和编译优化关系很大。-O0、-O1、-O2、-O3 是四档优化等级，O0 基本不优化，调试时最直观；优化等级越高，编译器越愿意少读内存、多用寄存器。

加了 volatile 之后，按下 ctrl+c，flag 置 1，while 能继续往下判断，程序正常结束。

不加 volatile 时，现象就不一样了：第一次按下 ctrl+c，信号处理函数确实执行了，但主循环没有及时看到 flag 的变化，程序还会停在原地；再按一次信号，才又有新的动作。

这背后不是信号失效，而是优化把'每次都去内存读'变成了'先放进寄存器再反复用'。对这类会被异步修改的变量，volatile 基本是最低成本的保险。