【Linux系统编程】（三十七）信号捕捉全链路拆解｜从内核态切换到 sigaction 实战

事件触发（如Ctrl+C）→ OS检测中断 → 保存当前进程上下文 → 执行中断处理逻辑（信号调度）→ 恢复进程上下文

#include <signal.h>

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

struct sigaction {
    // 信号处理函数指针（核心）
    void (*sa_handler)(int);
    // 替代的处理函数指针（支持传递信号附加信息，本文暂不展开）
    void (*sa_sigaction)(int, siginfo_t *, void *);
    // 信号屏蔽集：捕捉该信号期间，自动屏蔽的信号集合
    sigset_t sa_mask;
    // 行为控制标志（位掩码，控制信号处理的细节）
    int sa_flags;
    // 预留字段（未使用）
    void (*sa_restorer)(void);
};

void (*sa_sigaction)(int signum, siginfo_t *info, void *context);

// sigaction_basic.cpp
#include <iostream>
#include <unistd.h>
#include <signal.h>
using namespace std;

// 自定义信号处理函数
void sig_int_handler(int signum)
{
    cout << "\n[捕捉成功] 收到SIGINT信号（编号：" << signum << "），进程不终止！" << endl;
}

int main()
{
    cout << "进程PID：" << getpid() << "，等待SIGINT信号（按下Ctrl+C测试）..." << endl;

    struct sigaction act;
    // 1. 初始化结构体（必须！避免脏数据）
    // 方式1：手动置0
    // memset(&act, 0, sizeof(act));
    // 方式2：使用sigemptyset初始化sa_mask
    sigemptyset(&act.sa_mask);

    // 2. 设置处理函数
    act.sa_handler = sig_int_handler;
    // 3. 设置行为标志：默认（0）
    act.sa_flags = 0;

    // 4. 注册信号处理动作
    int ret = sigaction(SIGINT, &act, NULL);
    if (ret == -1)
    {
        perror("sigaction failed");
        return 1;
    }

    // 死循环，保持进程运行
    while (true)
    {
        sleep(1);
        cout << "进程正常运行中..." << endl;
    }

    return 0;
}

g++ sigaction_basic.cpp -o sigaction_basic
./sigaction_basic

// sigaction_samask.cpp
#include <iostream>
#include <unistd.h>
#include <signal.h>
using namespace std;

// 自定义处理函数（故意设置5秒延时，模拟耗时操作）
void sig_int_handler(int signum)
{
    cout << "\n[开始处理] SIGINT信号，耗时5秒..." << endl;
    // 模拟耗时处理
    for (int i = 0; i < 5; i++)
    {
        sleep(1);
        cout << "处理中：第" << i+1 << "秒" << endl;
    }
    cout << "[处理完成] SIGINT信号" << endl;
}

int main()
{
    cout << "进程PID：" << getpid() << endl;
    cout << "测试步骤：1. 按下Ctrl+C触发SIGINT；2. 处理期间按下Ctrl+\\触发SIGQUIT" << endl;

    struct sigaction act;
    sigemptyset(&act.sa_mask);

    // 核心：向sa_mask中添加SIGQUIT，处理SIGINT期间自动屏蔽SIGQUIT
    sigaddset(&act.sa_mask, SIGQUIT);
    // 额外：屏蔽自身，避免嵌套触发（sa_flags=0时，OS会自动屏蔽当前信号，此处为显式演示）
    sigaddset(&act.sa_mask, SIGINT);

    act.sa_handler = sig_int_handler;
    act.sa_flags = 0;

    // 注册SIGINT和SIGQUIT（SIGQUIT使用默认处理）
    sigaction(SIGINT, &act, NULL);
    // 注册SIGQUIT的默认处理（确保触发时终止进程）
    struct sigaction quit_act;
    sigemptyset(&quit_act.sa_mask);
    quit_act.sa_handler = SIG_DFL;
    quit_act.sa_flags = 0;
    sigaction(SIGQUIT, &quit_act, NULL);

    while (true)
    {
        sleep(1);
        cout << "进程正常运行中..." << endl;
    }

    return 0;
}

g++ sigaction_samask.cpp -o sigaction_samask
./sigaction_samask

// sigaction_sarestart.cpp
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <cstring>
using namespace std;

void sig_int_handler(int signum)
{
    cout << "\n捕捉到SIGINT信号，read系统调用将自动重启！" << endl;
}

int main()
{
    cout << "进程PID：" << getpid() << endl;
    cout << "测试：输入字符前按下Ctrl+C，观察read是否重启" << endl;

    struct sigaction act;
    sigemptyset(&act.sa_mask);
    act.sa_handler = sig_int_handler;
    // 核心：设置SA_RESTART，让慢系统调用自动重启
    act.sa_flags = SA_RESTART;
    // 对比测试：注释上面一行，使用act.sa_flags = 0，观察效果
    sigaction(SIGINT, &act, NULL);

    char buf[1024];
    cout << "请输入字符串：";
    // 慢系统调用：从标准输入读取数据，若不输入，会一直阻塞
    ssize_t ret = read(STDIN_FILENO, buf, sizeof(buf)-1);
    if (ret == -1)
    {
        if (errno == EINTR)
        {
            cerr << "read被信号中断，未重启！" << endl;
        }
        else
        {
            perror("read failed");
        }
        return 1;
    }

    buf[ret] = '\0';
    cout << "你输入的内容：" << buf << endl;

    return 0;
}

g++ sigaction_sarestart.cpp -o sigaction_sarestart
./sigaction_sarestart

// sigaction_saresethand.cpp
#include <iostream>
#include <unistd.h>
#include <signal.h>
using namespace std;

void sig_int_handler(int signum)
{
    cout << "\n捕捉到SIGINT信号（仅执行一次）！" << endl;
}

int main()
{
    cout << "进程PID：" << getpid() << endl;
    cout << "测试：第一次按Ctrl+C执行处理函数，第二次按Ctrl+C终止进程" << endl;

    struct sigaction act;
    sigemptyset(&act.sa_mask);
    act.sa_handler = sig_int_handler;
    // 核心：设置SA_RESETHAND，执行后恢复默认动作
    act.sa_flags = SA_RESETHAND;

    sigaction(SIGINT, &act, NULL);

    while (true)
    {
        sleep(1);
        cout << "进程正常运行中..." << endl;
    }

    return 0;
}

// sigaction_atomic.cpp
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <cstdlib>
using namespace std;

// 原信号处理动作（用于保存）
struct sigaction old_int_act, old_quit_act;

void sig_handler(int signum)
{
    cout << "\n捕捉到信号：" << signum << "（" << (signum == SIGINT ? "SIGINT" : "SIGQUIT") << "）" << endl;
}

// 退出时恢复原信号动作
void cleanup()
{
    sigaction(SIGINT, &old_int_act, NULL);
    sigaction(SIGQUIT, &old_quit_act, NULL);
    cout << "已恢复原信号处理动作，程序退出！" << endl;
}

int main()
{
    cout << "进程PID：" << getpid() << endl;
    atexit(cleanup); // 注册退出清理函数

    struct sigaction act;
    sigemptyset(&act.sa_mask);
    act.sa_handler = sig_handler;
    act.sa_flags = 0;

    // 核心：原子化设置，并保存原动作
    sigaction(SIGINT, &act, &old_int_act);
    sigaction(SIGQUIT, &act, &old_quit_act);

    cout << "已设置自定义信号处理动作，按下Ctrl+C或Ctrl+\\测试（30秒后自动退出）" << endl;
    sleep(30);

    return 0;
}

// sigaction_kill.cpp
#include <iostream>
#include <unistd.h>
#include <signal.h>
using namespace std;

void sig_kill_handler(int signum)
{
    cout << "捕捉到SIGKILL信号（这行代码永远不会执行）！" << endl;
}

int main()
{
    cout << "进程PID：" << getpid() << endl;

    struct sigaction act;
    sigemptyset(&act.sa_mask);
    act.sa_handler = sig_kill_handler;
    act.sa_flags = 0;

    // 尝试注册SIGKILL信号
    int ret = sigaction(SIGKILL, &act, NULL);
    if (ret == -1)
    {
        perror("sigaction SIGKILL failed");
        cout << "结论：SIGKILL信号不可捕捉、不可忽略！" << endl;
    }

    cout << "请在另一个终端执行：kill -9 " << getpid() << " 测试" << endl;
    sleep(20);

    return 0;
}

// sigaction_mask_comb.cpp
#include <iostream>
#include <unistd.h>
#include <signal.h>
using namespace std;

void sig_int_handler(int signum)
{
    cout << "\n===== 信号递达 =====" << endl;
    cout << "捕捉到SIGINT信号，执行处理函数" << endl;
    cout << "====================" << endl;
}

// 打印未决信号集
void print_pending()
{
    sigset_t pending;
    sigpending(&pending);
    cout << "[未决信号集]：";
    for (int i = 1; i <= 31; i++)
    {
        if (sigismember(&pending, i))
        {
            cout << i << " ";
        }
    }
    cout << endl;
}

int main()
{
    cout << "进程PID：" << getpid() << endl;

    // 1. 注册SIGINT处理函数
    struct sigaction act;
    sigemptyset(&act.sa_mask);
    act.sa_handler = sig_int_handler;
    act.sa_flags = 0;
    sigaction(SIGINT, &act, NULL);

    // 2. 阻塞SIGINT信号
    sigset_t block_set, old_set;
    sigemptyset(&block_set);
    sigaddset(&block_set, SIGINT);
    sigprocmask(SIG_BLOCK, &block_set, &old_set);
    cout << "已阻塞SIGINT信号，10秒内按下Ctrl+C测试..." << endl;

    // 3. 每隔2秒打印一次未决信号集
    for (int i = 0; i < 5; i++)
    {
        print_pending();
        sleep(2);
    }

    // 4. 解除阻塞
    sigprocmask(SIG_SETMASK, &old_set, NULL);
    cout << "已解除阻塞，未决信号立即递达！" << endl;

    while (true)
    {
        sleep(1);
        cout << "进程正常运行中..." << endl;
    }

    return 0;
}

// sigaction_reentrant.cpp
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <cstring>
using namespace std;

// 全局数组，模拟共享资源
char g_buf[1024];

// 不可重入函数：使用了全局变量，且包含多步操作
void unsafe_func(const char *str)
{
    // 第一步：清空缓冲区
    memset(g_buf, 0, sizeof(g_buf));
    // 模拟耗时操作（增加信号中断的概率）
    usleep(100000);
    // 第二步：拷贝数据（若此时被信号中断，会导致数据不完整）
    strcpy(g_buf, str);
    cout << "unsafe_func执行完成，g_buf：" << g_buf << endl;
}

// 信号处理函数：调用了不可重入函数unsafe_func
void sig_int_handler(int signum)
{
    cout << "\n信号处理函数：调用unsafe_func（信号）" << endl;
    unsafe_func("SIGNAL_DATA");
}

int main()
{
    cout << "进程PID：" << getpid() << endl;
    cout << "测试：程序运行后，快速按下Ctrl+C，触发信号中断" << endl;

    // 注册信号处理函数
    struct sigaction act;
    sigemptyset(&act.sa_mask);
    act.sa_handler = sig_int_handler;
    act.sa_flags = 0;
    sigaction(SIGINT, &act, NULL);

    // 主程序循环调用unsafe_func
    while (true)
    {
        cout << "主程序：调用unsafe_func（主程序）" << endl;
        unsafe_func("MAIN_DATA");
        sleep(1);
    }

    return 0;
}

// sigaction_reentrant_safe.cpp
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <cstring>
using namespace std;

// 全局标志：标记是否收到SIGINT信号
volatile sig_atomic_t g_sigint_received = 0;
// 全局数组
char g_buf[1024];

// 安全的处理函数（在主程序中执行）
void safe_handle_sigint()
{
    cout << "\n主程序处理SIGINT信号：" << endl;
    unsafe_func("SIGNAL_DATA"); // 此时可安全调用，因为主程序单线程执行
    g_sigint_received = 0; // 重置标志
}

// 不可重入函数（仅在主程序中调用）
void unsafe_func(const char *str)
{
    memset(g_buf, 0, sizeof(g_buf));
    usleep(100000);
    strcpy(g_buf, str);
    cout << "unsafe_func执行完成，g_buf：" << g_buf << endl;
}

// 信号处理函数：仅设置全局标志（原子操作）
void sig_int_handler(int signum)
{
    g_sigint_received = 1;
}

int main()
{
    cout << "进程PID：" << getpid() << endl;

    struct sigaction act;
    sigemptyset(&act.sa_mask);
    act.sa_handler = sig_int_handler;
    act.sa_flags = 0;
    sigaction(SIGINT, &act, NULL);

    while (true)
    {
        // 检查信号标志，若收到则处理
        if (g_sigint_received)
        {
            safe_handle_sigint();
            continue;
        }

        // 主程序业务逻辑
        cout << "主程序：调用unsafe_func（主程序）" << endl;
        unsafe_func("MAIN_DATA");
        usleep(50000);
    }

    return 0;
}

// sigaction_graceful_exit.cpp
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <cstdlib>
#include <cstdio>
using namespace std;

// 全局标志：标记是否需要退出
volatile sig_atomic_t g_quit = 0;

// 模拟资源句柄
FILE *g_log_file = NULL;
int g_socket_fd = 100; // 模拟套接字

// 信号处理函数：设置退出标志
void sig_quit_handler(int signum)
{
    cout << "\n收到退出信号：" << (signum == SIGINT ? "SIGINT" : "SIGTERM") << endl;
    g_quit = 1;
}

// 优雅退出函数：释放资源、保存日志
void graceful_exit()
{
    cout << "\n开始优雅退出，释放资源..." << endl;

    // 1. 关闭日志文件
    if (g_log_file)
    {
        fprintf(g_log_file, "程序优雅退出，时间：%ld\n", time(NULL));
        fclose(g_log_file);
        cout << "日志文件已关闭" << endl;
    }

    // 2. 关闭套接字
    cout << "套接字FD " << g_socket_fd << " 已关闭" << endl;

    // 3. 打印退出信息
    cout << "程序已优雅退出！" << endl;
}

int main()
{
    cout << "===== 后台服务程序启动 =====" << endl;
    cout << "进程PID：" << getpid() << endl;
    cout << "发送 SIGINT（Ctrl+C）或 SIGTERM（kill 进程PID）可触发优雅退出" << endl;

    // 初始化资源
    g_log_file = fopen("service.log", "a");
    if (!g_log_file)
    {
        perror("fopen failed");
        return 1;
    }
    fprintf(g_log_file, "程序启动，时间：%ld\n", time(NULL));
    cout << "日志文件已打开" << endl;

    // 注册退出清理函数
    atexit(graceful_exit);

    // 注册SIGINT和SIGTERM信号
    struct sigaction act;
    sigemptyset(&act.sa_mask);
    // 屏蔽SIGTERM，避免退出时被打断
    sigaddset(&act.sa_mask, SIGTERM);
    act.sa_handler = sig_quit_handler;
    act.sa_flags = 0;

    sigaction(SIGINT, &act, NULL);
    sigaction(SIGTERM, &act, NULL);

    // 服务主循环
    while (!g_quit)
    {
        // 模拟业务处理
        cout << "服务正在运行，处理请求中..." << endl;
        sleep(2);
    }

    cout << "主循环退出，准备执行清理操作..." << endl;

    return 0;
}

g++ sigaction_graceful_exit.cpp -o sigaction_graceful_exit
./sigaction_graceful_exit