The Linux Programming interface学习:Linux 信号处理函数设计

一、信号处理函数设计的两大黄金原则

设计信号处理函数时，最重要的一条原则是：尽量写得简单。原因是越复杂的处理函数，越容易引入难以调试的竞态条件（race condition）。 实践中有两种常见的设计模式： 模式一：设置标志位，主程序检查

信号处理函数只做一件事：把某个全局标志变量设为 1
主程序在循环中定期检查这个标志，再做真正的处理工作

模式二：清理后退出或跳转

信号处理函数做必要的清理（释放资源、关闭文件等）
然后调用 _exit() 终止进程，或用非本地跳转跳回主程序某处

二、可重入函数 vs 不可重入函数

2.1 什么是"可重入"？

想象一个函数正在被主程序执行到一半，这时信号来了，信号处理函数也调用了同一个函数。如果这种"同时执行"不会导致错误，这个函数就是可重入的（reentrant）。 形象比喻：

可重入函数 ≈ 每次调用都用自己独立的"草稿纸"（局部变量）
不可重入函数 ≈ 所有调用共用同一张"草稿纸"（全局/静态变量）

2.2 哪些函数是不可重入的？

不可重入的根本原因是函数内部使用了共享状态：

不可重入的原因
├── 使用了全局/静态数据结构
│ ├── malloc() / free() → 维护共享的空闲链表
│ ├── printf() / scanf() → 维护共享的 stdio 缓冲区
│ └── strtok() → 使用静态内部指针
└── 返回静态分配的内存（每次调用覆盖同一块内存）
├── crypt()
├── getpwnam()
├── gethostbyname()
└── getservbyname()

2.3 不可重入的危险示意

主程序调用 crypt("abc", "xx") ──────→ [crypt 开始写静态缓冲区]
│
← 信号到来，打断！──┘
│
↓
信号处理函数调用 crypt("def", "xx")
[crypt 用新结果覆盖了同一个静态缓冲区]
│
↓
信号处理函数返回
│
主程序继续 ─────→ 读取 crypt() 的返回值
[但缓冲区已被处理函数的结果覆盖！]
← 数据不一致，产生难以复现的 bug

三、异步信号安全函数（Async-Signal-Safe）

异步信号安全函数是指：可以在信号处理函数中安全调用的函数。它要么本身是可重入的，要么在执行期间不会被信号中断。

3.1 常用的安全函数列表（节选）

规则：凡是不在安全列表中的函数，都不应在信号处理函数中调用。 printf() 不在安全列表中，但教学示例中为了方便演示经常使用，实际项目中要避免。

3.2 errno 的保护

安全列表中的函数虽然可以调用，但它们可能会修改 errno，从而覆盖主程序中 errno 的值。解决方法：进入处理函数时保存 errno，退出前恢复。

void handler(int sig) {
int savedErrno = errno; // 保存主程序的 errno
// … 调用可能修改 errno 的安全函数 …
errno = savedErrno; // 恢复，不影响主程序
}

四、全局变量与 sig_atomic_t

4.1 为什么需要 volatile？

编译器为了优化性能，可能把变量缓存在寄存器里，不每次都从内存读取。但信号处理函数对全局变量的修改发生在内存中，如果主程序读的是寄存器里的旧值，就永远感知不到变化。 volatile 关键字告诉编译器：“每次都必须从内存读这个变量，不要缓存到寄存器”。

4.2 为什么需要 sig_atomic_t？

读写一个变量在底层可能需要多条机器指令（比如 64 位值在 32 位机器上）。如果信号在这几条指令中间打断，读到的是半新半旧的值，就会出错。 sig_atomic_t 保证读写操作是原子的（一条机器指令完成，不会被打断）。

4.3 正确的声明方式

// 在主程序和信号处理函数之间共享的标志变量，必须这样声明：
volatile sig_atomic_t flag = 0;
// volatile → 每次从内存读，不用寄存器缓存
// sig_atomic_t → 读写是原子操作，不会读到"中间状态"

注意：++ 和 — 运算符不保证原子性，即使对 sig_atomic_t 类型也不行。 只能做：在处理函数里设置它，在主程序里检查它（或反过来）。

五、从信号处理函数退出的多种方式

#mermaid-svg-9UQG66NcdkTbtdfN{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-9UQG66NcdkTbtdfN .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-9UQG66NcdkTbtdfN .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-9UQG66NcdkTbtdfN .error-icon{fill:#552222;}#mermaid-svg-9UQG66NcdkTbtdfN .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-9UQG66NcdkTbtdfN .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-9UQG66NcdkTbtdfN .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-9UQG66NcdkTbtdfN .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-9UQG66NcdkTbtdfN .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-9UQG66NcdkTbtdfN .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-9UQG66NcdkTbtdfN .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-9UQG66NcdkTbtdfN .marker{fill:#333333;stroke:#333333;}#mermaid-svg-9UQG66NcdkTbtdfN .marker.cross{stroke:#333333;}#mermaid-svg-9UQG66NcdkTbtdfN svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-9UQG66NcdkTbtdfN p{margin:0;}#mermaid-svg-9UQG66NcdkTbtdfN .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-9UQG66NcdkTbtdfN .cluster-label text{fill:#333;}#mermaid-svg-9UQG66NcdkTbtdfN .cluster-label span{color:#333;}#mermaid-svg-9UQG66NcdkTbtdfN .cluster-label span p{background-color:transparent;}#mermaid-svg-9UQG66NcdkTbtdfN .label text,#mermaid-svg-9UQG66NcdkTbtdfN span{fill:#333;color:#333;}#mermaid-svg-9UQG66NcdkTbtdfN .node rect,#mermaid-svg-9UQG66NcdkTbtdfN .node circle,#mermaid-svg-9UQG66NcdkTbtdfN .node ellipse,#mermaid-svg-9UQG66NcdkTbtdfN .node polygon,#mermaid-svg-9UQG66NcdkTbtdfN .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-9UQG66NcdkTbtdfN .rough-node .label text,#mermaid-svg-9UQG66NcdkTbtdfN .node .label text,#mermaid-svg-9UQG66NcdkTbtdfN .image-shape .label,#mermaid-svg-9UQG66NcdkTbtdfN .icon-shape .label{text-anchor:middle;}#mermaid-svg-9UQG66NcdkTbtdfN .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-9UQG66NcdkTbtdfN .rough-node .label,#mermaid-svg-9UQG66NcdkTbtdfN .node .label,#mermaid-svg-9UQG66NcdkTbtdfN .image-shape .label,#mermaid-svg-9UQG66NcdkTbtdfN .icon-shape .label{text-align:center;}#mermaid-svg-9UQG66NcdkTbtdfN .node.clickable{cursor:pointer;}#mermaid-svg-9UQG66NcdkTbtdfN .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-9UQG66NcdkTbtdfN .arrowheadPath{fill:#333333;}#mermaid-svg-9UQG66NcdkTbtdfN .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-9UQG66NcdkTbtdfN .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-9UQG66NcdkTbtdfN .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-9UQG66NcdkTbtdfN .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-9UQG66NcdkTbtdfN .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-9UQG66NcdkTbtdfN .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-9UQG66NcdkTbtdfN .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-9UQG66NcdkTbtdfN .cluster text{fill:#333;}#mermaid-svg-9UQG66NcdkTbtdfN .cluster span{color:#333;}#mermaid-svg-9UQG66NcdkTbtdfN div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-9UQG66NcdkTbtdfN .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-9UQG66NcdkTbtdfN rect.text{fill:none;stroke-width:0;}#mermaid-svg-9UQG66NcdkTbtdfN .icon-shape,#mermaid-svg-9UQG66NcdkTbtdfN .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-9UQG66NcdkTbtdfN .icon-shape p,#mermaid-svg-9UQG66NcdkTbtdfN .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-9UQG66NcdkTbtdfN .icon-shape .label rect,#mermaid-svg-9UQG66NcdkTbtdfN .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-9UQG66NcdkTbtdfN .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-9UQG66NcdkTbtdfN .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-9UQG66NcdkTbtdfN :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

正常 return

_exit()

exit()

kill() / raise()

abort()

siglongjmp()

longjmp()

信号处理函数被调用

退出方式?

主程序从中断处继续

进程立即终止（安全，不冲洗 stdio 缓冲）

危险！exit() 不在安全列表会冲洗 stdio 缓冲，可能崩溃

发送终止信号杀死进程

发送 SIGABRT产生 core dump 并终止

非本地跳转跳回主程序某处并正确恢复信号屏蔽字

非本地跳转但不恢复信号屏蔽字（Linux/System V 行为）

六、非本地跳转：sigsetjmp / siglongjmp

6.1 问题背景

信号处理函数执行时，内核会自动把触发该信号加入屏蔽字（防止处理函数被同一信号递归打断）。处理函数正常 return 时，内核会自动恢复屏蔽字。 但如果用 longjmp() 跳出处理函数，屏蔽字就永远不会被恢复，导致该信号从此被永久屏蔽！

6.2 longjmp vs siglongjmp 对比

使用 longjmp() 跳出信号处理函数：
信号处理函数入口 → SIGINT 加入屏蔽字
longjmp() 跳走 → 屏蔽字没有被恢复
结果：SIGINT 永久被屏蔽，再按 Ctrl+C 没有反应！
使用 siglongjmp() 跳出信号处理函数：
sigsetjmp(env, 1) → 保存当时的屏蔽字到 env
信号处理函数入口 → SIGINT 加入屏蔽字
siglongjmp(env,1) → 恢复 env 中保存的屏蔽字（SIGINT 被移除）
结果：一切正常，Ctrl+C 仍然有效

6.3 API

#include <setjmp.h>
// savesigs 非零时：保存当前信号屏蔽字到 env
// 初次调用返回 0；被 siglongjmp 跳回时返回非零值
int sigsetjmp(sigjmp_buf env, int savesigs);
// 跳回 sigsetjmp 调用处，并恢复信号屏蔽字（若 savesigs 非零）
void siglongjmp(sigjmp_buf env, int val);

6.4 守卫变量（canJump）

信号可能在 sigsetjmp() 执行之前就到达。此时 env 还没有初始化，如果处理函数贸然调用 siglongjmp()，会用一个垃圾值跳转，导致崩溃。 解决方案：用一个守卫变量 canJump，只有 sigsetjmp() 成功后才设为 1，处理函数先检查这个变量。

时序图：
主程序 信号处理函数
│
├─ canJump = 0
├─ 安装信号处理函数
├─ sigsetjmp() ← 此时 env 初始化完成
├─ canJump = 1
│
│ ← 信号到来
│ canJump == 1? 是
│ siglongjmp() 安全跳转
│
├─ 跳回 sigsetjmp() 之后继续

七、备用信号栈：sigaltstack()

7.1 为什么需要备用栈？

通常信号处理函数的栈帧建立在进程的主栈上。但如果主栈已经溢出（比如无限递归耗尽栈空间），内核会发送 SIGSEGV。 问题：栈已满 → 无法为 SIGSEGV 处理函数建立栈帧 → 处理函数无法执行 → 进程直接崩溃，无法做任何清理。 解决方案：预先分配一块独立内存作为备用信号栈，SIGSEGV 处理函数在备用栈上执行，不依赖已崩溃的主栈。

7.2 使用步骤

#mermaid-svg-kanJLwoVtI9S1l1t{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-kanJLwoVtI9S1l1t .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-kanJLwoVtI9S1l1t .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-kanJLwoVtI9S1l1t .error-icon{fill:#552222;}#mermaid-svg-kanJLwoVtI9S1l1t .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-kanJLwoVtI9S1l1t .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-kanJLwoVtI9S1l1t .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-kanJLwoVtI9S1l1t .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-kanJLwoVtI9S1l1t .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-kanJLwoVtI9S1l1t .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-kanJLwoVtI9S1l1t .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-kanJLwoVtI9S1l1t .marker{fill:#333333;stroke:#333333;}#mermaid-svg-kanJLwoVtI9S1l1t .marker.cross{stroke:#333333;}#mermaid-svg-kanJLwoVtI9S1l1t svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-kanJLwoVtI9S1l1t p{margin:0;}#mermaid-svg-kanJLwoVtI9S1l1t .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-kanJLwoVtI9S1l1t .cluster-label text{fill:#333;}#mermaid-svg-kanJLwoVtI9S1l1t .cluster-label span{color:#333;}#mermaid-svg-kanJLwoVtI9S1l1t .cluster-label span p{background-color:transparent;}#mermaid-svg-kanJLwoVtI9S1l1t .label text,#mermaid-svg-kanJLwoVtI9S1l1t span{fill:#333;color:#333;}#mermaid-svg-kanJLwoVtI9S1l1t .node rect,#mermaid-svg-kanJLwoVtI9S1l1t .node circle,#mermaid-svg-kanJLwoVtI9S1l1t .node ellipse,#mermaid-svg-kanJLwoVtI9S1l1t .node polygon,#mermaid-svg-kanJLwoVtI9S1l1t .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-kanJLwoVtI9S1l1t .rough-node .label text,#mermaid-svg-kanJLwoVtI9S1l1t .node .label text,#mermaid-svg-kanJLwoVtI9S1l1t .image-shape .label,#mermaid-svg-kanJLwoVtI9S1l1t .icon-shape .label{text-anchor:middle;}#mermaid-svg-kanJLwoVtI9S1l1t .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-kanJLwoVtI9S1l1t .rough-node .label,#mermaid-svg-kanJLwoVtI9S1l1t .node .label,#mermaid-svg-kanJLwoVtI9S1l1t .image-shape .label,#mermaid-svg-kanJLwoVtI9S1l1t .icon-shape .label{text-align:center;}#mermaid-svg-kanJLwoVtI9S1l1t .node.clickable{cursor:pointer;}#mermaid-svg-kanJLwoVtI9S1l1t .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-kanJLwoVtI9S1l1t .arrowheadPath{fill:#333333;}#mermaid-svg-kanJLwoVtI9S1l1t .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-kanJLwoVtI9S1l1t .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-kanJLwoVtI9S1l1t .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-kanJLwoVtI9S1l1t .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-kanJLwoVtI9S1l1t .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-kanJLwoVtI9S1l1t .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-kanJLwoVtI9S1l1t .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-kanJLwoVtI9S1l1t .cluster text{fill:#333;}#mermaid-svg-kanJLwoVtI9S1l1t .cluster span{color:#333;}#mermaid-svg-kanJLwoVtI9S1l1t div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-kanJLwoVtI9S1l1t .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-kanJLwoVtI9S1l1t rect.text{fill:none;stroke-width:0;}#mermaid-svg-kanJLwoVtI9S1l1t .icon-shape,#mermaid-svg-kanJLwoVtI9S1l1t .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-kanJLwoVtI9S1l1t .icon-shape p,#mermaid-svg-kanJLwoVtI9S1l1t .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-kanJLwoVtI9S1l1t .icon-shape .label rect,#mermaid-svg-kanJLwoVtI9S1l1t .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-kanJLwoVtI9S1l1t .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-kanJLwoVtI9S1l1t .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-kanJLwoVtI9S1l1t :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

1. 分配一块内存作为备用栈（malloc 或静态数组）

2. 调用 sigaltstack()告诉内核备用栈的位置

3. 安装信号处理函数时指定 SA_ONSTACK 标志

信号到来时内核自动在备用栈上建立处理函数的栈帧

7.3 stack_t 结构体

typedef struct {
void *ss_sp; // 备用栈的起始地址
int ss_flags; // SS_ONSTACK（正在使用中）或 SS_DISABLE（禁用）
size_t ss_size; // 备用栈的大小（字节）
} stack_t;

备用栈推荐大小：SIGSTKSZ（通常是 8192 字节），最小不能低于 MINSIGSTKSZ（通常是 2048 字节）。

八、SA_SIGINFO：获取信号的详细信息

8.1 普通处理函数 vs SA_SIGINFO 处理函数

普通处理函数：
void handler(int sig)
只知道信号编号，不知道信号是谁发的、为什么发的
SA_SIGINFO 处理函数：
void handler(int sig, siginfo_t *siginfo, void *ucontext)
多了 siginfo_t 结构体，包含信号的详细来源信息

8.2 siginfo_t 结构体关键字段

typedef struct {
int si_signo; // 信号编号（与 sig 参数相同）
int si_code; // 信号来源代码（见下表）
pid_t si_pid; // 发送方的进程 ID（kill()/sigqueue() 发送时有效）
uid_t si_uid; // 发送方的真实用户 ID
void *si_addr; // 导致硬件异常的地址（SIGSEGV/SIGBUS/SIGILL/SIGFPE 有效）
int si_status; // 子进程的退出状态或信号编号（SIGCHLD 有效）
// … 其他字段根据信号类型不同而不同
} siginfo_t;

8.3 si_code 常用值

8.4 安装 SA_SIGINFO 处理函数

struct sigaction act;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_SIGINFO; // 关键：设置此标志
act.sa_sigaction = handler; // 注意：用 sa_sigaction，不是 sa_handler
sigaction(SIGINT, &act, nullptr);

九、系统调用被信号中断：EINTR 与 SA_RESTART

9.1 问题描述

进程正在执行 read()，等待终端输入（阻塞中）
│
← 信号到来，处理函数被调用
│
处理函数执行完毕，返回
│
read() 怎么办？
→ 默认行为：返回 -1，errno = EINTR（"被中断"）
→ 调用者必须自己处理这个错误

9.2 三种处理方案

方案一：手动重试循环

ssize_t cnt;
// 如果 read() 因信号中断（EINTR），就重新调用
while ((cnt = read(fd, buf, BUF_SIZE)) == –1 && errno == EINTR)
continue; // 循环体为空，直接重试
if (cnt == –1)
perror("read"); // 其他错误才报错

方案二：宏封装

// 定义一个宏，自动处理 EINTR 重试
#define NO_EINTR(stmt) while ((stmt) == –1 && errno == EINTR)
// 使用方式
ssize_t cnt;
NO_EINTR(cnt = read(fd, buf, BUF_SIZE));
if (cnt == –1)
perror("read");

方案三：SA_RESTART（推荐） 安装处理函数时指定 SA_RESTART，被中断的系统调用由内核自动重启，调用者完全不用处理 EINTR。

struct sigaction sa;
sa.sa_handler = handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART; // 系统调用被中断后自动重启
sigaction(SIGINT, &sa, nullptr);

9.3 SA_RESTART 有效 vs 无效的系统调用

十、完整示例代码（C++）

示例一：演示不可重入的危险（crypt 版）

// nonreentrant_demo.cpp
// 编译: g++ -o nonreentrant_demo nonreentrant_demo.cpp -lcrypt
// 运行: ./nonreentrant_demo abc def
// 运行后反复按 Ctrl+C，观察不一致输出
#define _XOPEN_SOURCE 600
#include <unistd.h> // crypt(), sleep()
#include <csignal>
#include <cstring>
#include <cstdio>
#include <cstdlib>
// 全局变量，供信号处理函数使用
static const char* str2 = nullptr;
static int handled = 0;
// 信号处理函数：调用 crypt()（不可重入函数）
static void handler(int sig) {
// 这里调用 crypt() 会覆盖主程序 crypt() 使用的同一个静态缓冲区
crypt(str2, "xx");
handled++;
}
int main(int argc, char* argv[]) {
if (argc != 3) {
fprintf(stderr, "用法: %s str1 str2\\n", argv[0]);
return EXIT_FAILURE;
}
str2 = argv[2];
// 第一步：用 argv[1] 加密，把结果复制到独立缓冲区
// strdup 内部调用 malloc，动态分配内存，所以不会被覆盖
char* cr1 = strdup(crypt(argv[1], "xx"));
if (cr1 == nullptr) {
perror("strdup");
return EXIT_FAILURE;
}
// 为 SIGINT 安装处理函数
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sa.sa_handler = handler;
if (sigaction(SIGINT, &sa, nullptr) == –1) {
perror("sigaction");
return EXIT_FAILURE;
}
printf("开始循环，请反复按 Ctrl+C，按 Ctrl+\\\\ 退出\\n");
int callNum = 0, mismatch = 0;
for (;;) {
callNum++;
// 每次调用 crypt(argv[1]) 应该与 cr1 相同
// 但如果处理函数在此期间被调用，就会覆盖 crypt() 的静态缓冲区
if (strcmp(crypt(argv[1], "xx"), cr1) != 0) {
mismatch++;
printf("第 %d 次调用发现不一致 (mismatch=%d, handled=%d)\\n",
callNum, mismatch, handled);
}
}
}

示例二：正确设计 — 标志位模式

// flag_pattern_demo.cpp
// 编译: g++ -o flag_pattern_demo flag_pattern_demo.cpp
// 运行后按 Ctrl+C，主循环检测到标志后优雅退出
#include <csignal>
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
#include <cerrno>
// 正确的共享标志变量声明方式
// volatile: 禁止编译器缓存到寄存器
// sig_atomic_t: 读写是原子操作
static volatile sig_atomic_t gotSigint = 0;
// 信号处理函数：只做一件事——设置标志
// 不调用任何不安全的函数
static void sigintHandler(int sig) {
gotSigint = 1;
// 注意：不在这里做复杂操作，也不调用 printf 等不安全函数
}
int main() {
struct sigaction sa;
sa.sa_handler = sigintHandler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
if (sigaction(SIGINT, &sa, nullptr) == –1) {
perror("sigaction");
return EXIT_FAILURE;
}
printf("程序运行中，按 Ctrl+C 优雅退出…\\n");
int count = 0;
// 主循环：定期检查标志
while (!gotSigint) {
// 实际业务逻辑
count++;
// 用 sleep 模拟工作，SA_RESTART 未设置，所以 SIGINT 会打断 sleep
// 这里我们检查 EINTR 并继续（因为我们要靠 gotSigint 来退出）
int ret = sleep(1);
(void)ret; // 被信号中断时 sleep 返回剩余秒数，此处忽略
// 检查标志（也可以在此处处理业务）
if (!gotSigint) {
printf("工作循环第 %d 次\\n", count);
}
}
// 收到 SIGINT 后，在主程序中安全地做清理工作
printf("\\n收到 SIGINT，正在清理并退出…\\n");
printf("共执行了 %d 次循环\\n", count);
return EXIT_SUCCESS;
}

示例三：sigsetjmp/siglongjmp 非本地跳转

// siglongjmp_demo.cpp
// 编译: g++ -D_GNU_SOURCE -o siglongjmp_demo siglongjmp_demo.cpp
// 运行后按 Ctrl+C，观察信号屏蔽字的恢复情况
#define _GNU_SOURCE
#include <csignal>
#include <csetjmp>
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
#include <cstring>
// 守卫变量：sigsetjmp 执行完才置 1
// 防止 env 未初始化时被 siglongjmp 使用
static volatile sig_atomic_t canJump = 0;
// 保存跳转目标（包含信号屏蔽字信息）
static sigjmp_buf jumpEnv;
// 打印当前信号屏蔽字（教学用，实际不应在处理函数中调用）
static void printMask(const char* msg) {
sigset_t mask;
sigprocmask(SIG_BLOCK, nullptr, &mask);
printf("%s\\n", msg);
// 检查常见信号是否在屏蔽字中
if (sigismember(&mask, SIGINT))
printf(" SIGINT 在屏蔽字中（被屏蔽）\\n");
else
printf(" SIGINT 不在屏蔽字中（未屏蔽）\\n");
}
static void sigintHandler(int sig) {
// UNSAFE: printf 不是异步信号安全函数，仅用于演示
printf("\\n— 进入信号处理函数 —\\n");
printMask("处理函数内的屏蔽字："); // 此时 SIGINT 被自动加入屏蔽字
if (!canJump) {
// env 还没准备好，直接返回
printf("env 未初始化，直接返回\\n");
return;
}
// 跳回 sigsetjmp 调用处，同时恢复屏蔽字（因为 savesigs=1）
siglongjmp(jumpEnv, 1);
}
int main() {
struct sigaction sa;
sa.sa_handler = sigintHandler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGINT, &sa, nullptr);
printMask("程序启动时的屏蔽字：");
// sigsetjmp 第一次调用返回 0
// 被 siglongjmp 跳回后返回非零值（这里是 1）
if (sigsetjmp(jumpEnv, 1) == 0) {
// 第一次执行：sigsetjmp 保存了当前屏蔽字（SIGINT 未屏蔽）
canJump = 1; // env 已初始化，处理函数可以安全跳转
printf("sigsetjmp() 已设置，等待 Ctrl+C…\\n");
} else {
// 从 siglongjmp 跳回：屏蔽字已恢复（SIGINT 重新未屏蔽）
printf("— 从处理函数跳回主程序 —\\n");
printMask("跳回后的屏蔽字：");
printf("Ctrl+C 仍然有效（信号屏蔽字已正确恢复）\\n\\n");
printf("再次等待 Ctrl+C…\\n");
}
// 无限等待信号
for (;;) {
pause(); // 等待任意信号
}
}

示例四：备用信号栈处理栈溢出

// sigaltstack_demo.cpp
// 编译: g++ -o sigaltstack_demo sigaltstack_demo.cpp
// 运行: ulimit -s unlimited && ./sigaltstack_demo
// 演示栈溢出时在备用栈上捕获 SIGSEGV
#define _GNU_SOURCE
#include <csignal>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
// SIGSEGV 处理函数（运行在备用栈上）
static void sigsegvHandler(int sig) {
// 声明一个局部变量，用其地址观察当前栈位置
int localVar;
// UNSAFE: printf 不安全，仅用于演示
printf("\\n捕获到信号 %d (段错误)\\n", sig);
printf("处理函数的栈顶附近地址: %p\\n", (void*)&localVar);
printf("（这是备用信号栈，与已溢出的主栈无关）\\n");
fflush(nullptr);
// 必须用 _exit() 而不是 exit()
// exit() 在安全函数列表之外，且可能尝试冲洗已损坏的 stdio 缓冲区
_exit(EXIT_FAILURE);
}
// 无限递归，故意让主栈溢出
static void overflowStack(int depth) {
// 每个栈帧分配 10000 字节，加速栈溢出
char bigArray[10000];
bigArray[0] = (char)depth; // 防止编译器优化掉这个数组
printf("递归深度 %4d, 栈帧地址: %p\\n", depth, (void*)bigArray);
overflowStack(depth + 1); // 无限递归
}
int main() {
// 步骤1：分配备用信号栈内存
stack_t altStack;
altStack.ss_sp = malloc(SIGSTKSZ); // SIGSTKSZ 通常是 8192 字节
if (altStack.ss_sp == nullptr) {
perror("malloc");
return EXIT_FAILURE;
}
altStack.ss_size = SIGSTKSZ;
altStack.ss_flags = 0; // 不设置任何标志
// 步骤2：告知内核备用栈的位置
if (sigaltstack(&altStack, nullptr) == –1) {
perror("sigaltstack");
return EXIT_FAILURE;
}
printf("备用信号栈已设置: %p – %p\\n",
altStack.ss_sp,
(char*)altStack.ss_sp + SIGSTKSZ – 1);
// 步骤3：安装 SIGSEGV 处理函数，指定使用备用栈
struct sigaction sa;
sa.sa_handler = sigsegvHandler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_ONSTACK; // 关键：在备用栈上运行处理函数
if (sigaction(SIGSEGV, &sa, nullptr) == –1) {
perror("sigaction");
return EXIT_FAILURE;
}
int localVar;
printf("主栈起始地址附近: %p\\n\\n", (void*)&localVar);
printf("开始无限递归（将导致栈溢出）…\\n\\n");
// 触发栈溢出
overflowStack(1);
return EXIT_SUCCESS; // 不会到达这里
}

示例五：SA_SIGINFO 获取信号详细信息

// sa_siginfo_demo.cpp
// 编译: g++ -o sa_siginfo_demo sa_siginfo_demo.cpp
// 在另一个终端运行: kill -SIGUSR1 <本进程PID>
// 观察发送方的进程 ID 和用户 ID 信息
#include <csignal>
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
// SA_SIGINFO 处理函数：有三个参数
// sig : 信号编号
// siginfo : 包含信号详细信息的结构体
// ucontext: 进程被中断前的上下文（通常不需要）
static void handler(int sig, siginfo_t* siginfo, void* ucontext) {
// UNSAFE: printf 不安全，仅用于演示
printf("\\n收到信号: %d\\n", sig);
printf("si_code: %d ", siginfo->si_code);
// 根据 si_code 解释信号来源
switch (siginfo->si_code) {
case SI_USER:
printf("(来自用户进程 kill() 或 raise())\\n");
printf("发送方 PID: %ld\\n", (long)siginfo->si_pid);
printf("发送方 UID: %ld\\n", (long)siginfo->si_uid);
break;
case SI_KERNEL:
printf("(来自内核)\\n");
break;
case SI_QUEUE:
printf("(来自 sigqueue())\\n");
printf("发送方 PID: %ld\\n", (long)siginfo->si_pid);
break;
default:
printf("(其他来源)\\n");
break;
}
// 对于 SIGSEGV：打印导致错误的内存地址
if (sig == SIGSEGV) {
printf("导致错误的地址: %p\\n", siginfo->si_addr);
}
}
int main() {
struct sigaction sa;
sigemptyset(&sa.sa_mask);
// 关键：必须设置 SA_SIGINFO，并使用 sa_sigaction（不是 sa_handler）
sa.sa_flags = SA_SIGINFO;
sa.sa_sigaction = handler; // 注意：用 sa_sigaction 字段
if (sigaction(SIGUSR1, &sa, nullptr) == –1) {
perror("sigaction");
return EXIT_FAILURE;
}
if (sigaction(SIGUSR2, &sa, nullptr) == –1) {
perror("sigaction");
return EXIT_FAILURE;
}
printf("本进程 PID: %ld\\n", (long)getpid());
printf("等待信号中…\\n");
printf("在另一个终端运行: kill -SIGUSR1 %ld\\n", (long)getpid());
for (;;) {
pause(); // 等待信号
}
}

示例六：SA_RESTART 自动重启系统调用

// sa_restart_demo.cpp
// 编译: g++ -o sa_restart_demo sa_restart_demo.cpp
// 运行后按 Ctrl+C，观察 read() 是否被自动重启（等待继续输入）
#include <csignal>
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
#include <cerrno>
#include <cstring>
static void sigintHandler(int sig) {
// UNSAFE: 仅用于演示
const char msg[] = "\\n[处理函数] 收到 SIGINT，read() 将自动重启\\n";
// 用 write() 而不是 printf()（write 是异步信号安全的）
write(STDOUT_FILENO, msg, sizeof(msg) – 1);
}
int main() {
struct sigaction sa;
sa.sa_handler = sigintHandler;
sigemptyset(&sa.sa_mask);
// SA_RESTART: 被信号中断的系统调用自动重启，无需手动处理 EINTR
sa.sa_flags = SA_RESTART;
if (sigaction(SIGINT, &sa, nullptr) == –1) {
perror("sigaction");
return EXIT_FAILURE;
}
char buf[256];
printf("请输入内容（按 Ctrl+C 测试 SA_RESTART，按 Ctrl+D 结束）:\\n");
// 有了 SA_RESTART，不需要处理 EINTR，read() 会自动重启
ssize_t numRead = read(STDIN_FILENO, buf, sizeof(buf) – 1);
if (numRead == –1) {
// 注意：即使设了 SA_RESTART，某些系统调用仍会返回 EINTR
// 如果不设 SA_RESTART，这里几乎必然看到 EINTR
printf("read() 失败: %s\\n", strerror(errno));
return EXIT_FAILURE;
}
if (numRead == 0) {
printf("读到 EOF\\n");
} else {
buf[numRead] = '\\0';
printf("读到 %zd 字节: %s", numRead, buf);
}
return EXIT_SUCCESS;
}

十一、知识点总结脑图

#mermaid-svg-SUKay5SWaFqQd7Rp{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-SUKay5SWaFqQd7Rp .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-SUKay5SWaFqQd7Rp .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-SUKay5SWaFqQd7Rp .error-icon{fill:#552222;}#mermaid-svg-SUKay5SWaFqQd7Rp .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-SUKay5SWaFqQd7Rp .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-SUKay5SWaFqQd7Rp .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-SUKay5SWaFqQd7Rp .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-SUKay5SWaFqQd7Rp .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-SUKay5SWaFqQd7Rp .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-SUKay5SWaFqQd7Rp .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-SUKay5SWaFqQd7Rp .marker{fill:#333333;stroke:#333333;}#mermaid-svg-SUKay5SWaFqQd7Rp .marker.cross{stroke:#333333;}#mermaid-svg-SUKay5SWaFqQd7Rp svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-SUKay5SWaFqQd7Rp p{margin:0;}#mermaid-svg-SUKay5SWaFqQd7Rp .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-SUKay5SWaFqQd7Rp .cluster-label text{fill:#333;}#mermaid-svg-SUKay5SWaFqQd7Rp .cluster-label span{color:#333;}#mermaid-svg-SUKay5SWaFqQd7Rp .cluster-label span p{background-color:transparent;}#mermaid-svg-SUKay5SWaFqQd7Rp .label text,#mermaid-svg-SUKay5SWaFqQd7Rp span{fill:#333;color:#333;}#mermaid-svg-SUKay5SWaFqQd7Rp .node rect,#mermaid-svg-SUKay5SWaFqQd7Rp .node circle,#mermaid-svg-SUKay5SWaFqQd7Rp .node ellipse,#mermaid-svg-SUKay5SWaFqQd7Rp .node polygon,#mermaid-svg-SUKay5SWaFqQd7Rp .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-SUKay5SWaFqQd7Rp .rough-node .label text,#mermaid-svg-SUKay5SWaFqQd7Rp .node .label text,#mermaid-svg-SUKay5SWaFqQd7Rp .image-shape .label,#mermaid-svg-SUKay5SWaFqQd7Rp .icon-shape .label{text-anchor:middle;}#mermaid-svg-SUKay5SWaFqQd7Rp .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-SUKay5SWaFqQd7Rp .rough-node .label,#mermaid-svg-SUKay5SWaFqQd7Rp .node .label,#mermaid-svg-SUKay5SWaFqQd7Rp .image-shape .label,#mermaid-svg-SUKay5SWaFqQd7Rp .icon-shape .label{text-align:center;}#mermaid-svg-SUKay5SWaFqQd7Rp .node.clickable{cursor:pointer;}#mermaid-svg-SUKay5SWaFqQd7Rp .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-SUKay5SWaFqQd7Rp .arrowheadPath{fill:#333333;}#mermaid-svg-SUKay5SWaFqQd7Rp .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-SUKay5SWaFqQd7Rp .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-SUKay5SWaFqQd7Rp .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-SUKay5SWaFqQd7Rp .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-SUKay5SWaFqQd7Rp .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-SUKay5SWaFqQd7Rp .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-SUKay5SWaFqQd7Rp .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-SUKay5SWaFqQd7Rp .cluster text{fill:#333;}#mermaid-svg-SUKay5SWaFqQd7Rp .cluster span{color:#333;}#mermaid-svg-SUKay5SWaFqQd7Rp div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-SUKay5SWaFqQd7Rp .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-SUKay5SWaFqQd7Rp rect.text{fill:none;stroke-width:0;}#mermaid-svg-SUKay5SWaFqQd7Rp .icon-shape,#mermaid-svg-SUKay5SWaFqQd7Rp .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-SUKay5SWaFqQd7Rp .icon-shape p,#mermaid-svg-SUKay5SWaFqQd7Rp .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-SUKay5SWaFqQd7Rp .icon-shape .label rect,#mermaid-svg-SUKay5SWaFqQd7Rp .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-SUKay5SWaFqQd7Rp .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-SUKay5SWaFqQd7Rp .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-SUKay5SWaFqQd7Rp :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

信号处理函数设计

安全性问题

退出方式

系统调用中断

高级特性

可重入 vs 不可重入（避免全局/静态状态）

只调用异步信号安全函数（见 Table 21-1）

保存/恢复 errno

全局标志用volatile sig_atomic_t

正常 return（最常见）

_exit()（立即终止，安全）

abort()（产生 core dump）

siglongjmp()（非本地跳转，恢复屏蔽字）

默认: 返回 EINTR

手动重试循环

SA_RESTART内核自动重启

sigaltstack()备用栈处理栈溢出

SA_SIGINFO获取信号详细信息

十二、常见陷阱速查

Linux 信号高级特性 — 详细中文解析

一、核心转储（Core Dump）

1.1 什么是 core dump？

当某些信号（如 SIGSEGV、SIGQUIT）导致进程终止时，内核会把进程当时的内存镜像写入一个文件，这就是 core dump（核心转储）。调试器（如 gdb）可以加载这个文件，查看程序崩溃时的状态：变量的值、调用栈、寄存器内容等。

触发方式示例：
$ ulimit -c unlimited # 取消 core 文件大小限制
$ cat /proc/sys/kernel/core_pattern # 查看 core 文件会写到哪里
# 临时改回直接生成文件（当前目录）
$ sudo sysctl -w kernel.core_pattern=core
$ sleep 30
按 Ctrl+\\ # 发送 SIGQUIT
Quit (core dumped) # shell 提示发生了 core dump
$ ls -l core # 默认文件名为 "core"
-rw——- 1 user users 57344 Nov 30 13:39 core

1.2 不会产生 core dump 的情况

以下情况下 core dump 不会被生成：

不产生 core dump 的情况：
├── 进程对目标目录无写权限
├── 同名文件已存在且不可写，或不是普通文件
├── 同名文件存在但有多个硬链接
├── 目标目录不存在
├── RLIMIT_CORE 资源限制为 0（ulimit -c 0）
├── RLIMIT_FSIZE 文件大小限制为 0
├── 可执行文件没有读权限（防止逆向）
├── 文件系统只读、已满或 inode 耗尽
└── set-user-ID 程序被非属主用户执行
（防止恶意用户从 core 中提取敏感信息如密码）

1.3 自定义 core dump 文件名

Linux 通过 /proc/sys/kernel/core_pattern 控制 core 文件的命名规则：

# 查看当前规则
cat /proc/sys/kernel/core_pattern
# 默认输出: core
# 自定义示例：包含进程ID和信号编号
echo "core.%e.%p.%s" > /proc/sys/kernel/core_pattern

内核 2.6.19 起：若 core_pattern 以 | 开头，则其后内容被当作程序执行，core 数据写入该程序的标准输入（而非文件），例如 |/usr/lib/systemd/systemd-coredump。

二、特殊信号的投递规则

2.1 SIGKILL 和 SIGSTOP

这两个信号不可屏蔽、不可忽略、不可捕获，设计上如此，以保证系统管理员总能控制失控进程。尝试用 signal() 或 sigaction() 改变它们的处置会返回错误。

2.2 SIGCONT 与停止信号的特殊互动

#mermaid-svg-AIBSwD5ZgpyOjIfJ{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-AIBSwD5ZgpyOjIfJ .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .error-icon{fill:#552222;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .marker{fill:#333333;stroke:#333333;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .marker.cross{stroke:#333333;}#mermaid-svg-AIBSwD5ZgpyOjIfJ svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-AIBSwD5ZgpyOjIfJ p{margin:0;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .cluster-label text{fill:#333;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .cluster-label span{color:#333;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .cluster-label span p{background-color:transparent;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .label text,#mermaid-svg-AIBSwD5ZgpyOjIfJ span{fill:#333;color:#333;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .node rect,#mermaid-svg-AIBSwD5ZgpyOjIfJ .node circle,#mermaid-svg-AIBSwD5ZgpyOjIfJ .node ellipse,#mermaid-svg-AIBSwD5ZgpyOjIfJ .node polygon,#mermaid-svg-AIBSwD5ZgpyOjIfJ .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .rough-node .label text,#mermaid-svg-AIBSwD5ZgpyOjIfJ .node .label text,#mermaid-svg-AIBSwD5ZgpyOjIfJ .image-shape .label,#mermaid-svg-AIBSwD5ZgpyOjIfJ .icon-shape .label{text-anchor:middle;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .rough-node .label,#mermaid-svg-AIBSwD5ZgpyOjIfJ .node .label,#mermaid-svg-AIBSwD5ZgpyOjIfJ .image-shape .label,#mermaid-svg-AIBSwD5ZgpyOjIfJ .icon-shape .label{text-align:center;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .node.clickable{cursor:pointer;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .arrowheadPath{fill:#333333;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-AIBSwD5ZgpyOjIfJ .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-AIBSwD5ZgpyOjIfJ .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-AIBSwD5ZgpyOjIfJ .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .cluster text{fill:#333;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .cluster span{color:#333;}#mermaid-svg-AIBSwD5ZgpyOjIfJ div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-AIBSwD5ZgpyOjIfJ rect.text{fill:none;stroke-width:0;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .icon-shape,#mermaid-svg-AIBSwD5ZgpyOjIfJ .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .icon-shape p,#mermaid-svg-AIBSwD5ZgpyOjIfJ .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .icon-shape .label rect,#mermaid-svg-AIBSwD5ZgpyOjIfJ .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-AIBSwD5ZgpyOjIfJ .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-AIBSwD5ZgpyOjIfJ .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-AIBSwD5ZgpyOjIfJ :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

是

否

进程处于停止状态

收到 SIGCONT?

立即恢复执行（即使 SIGCONT 被屏蔽或忽略）

若 SIGCONT 被屏蔽：恢复后再投递处理函数

收到其他信号?

信号保持待决直到收到 SIGCONT 恢复后才投递

例外：SIGKILL 立即生效

SIGCONT 与停止信号的消抵规则：

• 投递 SIGCONT 时：丢弃所有待决的停止信号（SIGSTOP/SIGTSTP/SIGTTIN/SIGTTOU）
• 投递任何停止信号时：丢弃待决的 SIGCONT 这样做是为了防止"先发的停止信号在 SIGCONT 之后才生效"导致逻辑混乱。

三、进程睡眠状态与信号

Linux 内核区分两种（以及一种新增的）睡眠状态：

D 状态的进程如果长时间"挂住"（NFS 问题、内核 bug），即使 SIGKILL 也无效，只能重启系统。TASK_KILLABLE 状态就是为了缓解这个问题。

四、硬件生成信号的特殊性

SIGBUS、SIGFPE、SIGILL、SIGSEGV 可由硬件异常触发。对这类信号，以下行为是未定义的或有害的：

硬件生成信号的三种错误处理方式：
1. 处理函数正常 return：
进程回到出错的那条指令 → 再次触发同一信号 → 无限循环调用处理函数
2. 忽略信号（SIG_IGN）：
内核会强制投递，忽略设置无效
程序无法继续正常执行
3. 屏蔽信号：
Linux 2.6+ 中：进程被该信号立即杀死（即使安装了处理函数）
目的：避免死锁和隐藏 bug

正确的做法：

硬件生成信号的正确处理：
├── 接受默认动作（进程终止 + core dump）
├── 处理函数中调用 _exit() 终止进程
└── 处理函数中调用 siglongjmp() 跳到安全位置
（不能正常 return！）

五、同步信号 vs 异步信号

注意：同步/异步是信号产生方式的属性，不是信号本身的属性。同一个信号（如 SIGUSR1）可以被同步（raise()）或异步（另一个进程 kill()）地产生。 异步信号的投递时机：下次从内核态切回用户态时，包括：

• 进程重新被调度运行（时间片开始）
• 系统调用完成时

六、多个待决信号的投递顺序

当 sigprocmask() 解除屏蔽，多个待决信号同时"放开"时：

• Linux 当前实现：按信号编号升序投递（编号小的先投递）
• SUSv3 规定：多个标准信号的投递顺序由实现决定，不可依赖
• 实时信号：保证编号小的先投递（有优先级） 当多个信号同时解除屏蔽，且在处理第一个信号的处理函数执行期间发生内核态→用户态切换，第二个信号的处理函数会打断第一个处理函数的执行：

时序示意：
主程序
│
├─ 解除屏蔽（SIGINT + SIGQUIT 同时待决）
│
↓ 内核调用 SIGINT 处理函数（编号2，先）
│
SIGINT 处理函数执行中…
│
├─ 做了系统调用（发生内核→用户切换）
│
↓ 内核调用 SIGQUIT 处理函数（编号3，后）
│
SIGQUIT 处理函数执行并返回
│
SIGINT 处理函数继续并返回
│
主程序继续

七、实时信号（Realtime Signals）

7.1 实时信号 vs 标准信号

不要硬编码实时信号的数字值（如 44），应用 SIGRTMIN+n 表示，因为不同实现的范围不同。

7.2 发送实时信号：sigqueue()

#include <signal.h>
int sigqueue(pid_t pid, int sig, const union sigval value);
// 成功返回 0，失败返回 -1
// 队列满时返回 -1，errno=EAGAIN（需要稍后重试）
union sigval {
int sival_int; // 整数数据
void *sival_ptr; // 指针数据（跨进程几乎无意义）
};

权限要求与 kill() 相同。pid 不能为负（不能发给进程组）。

7.3 接收实时信号

接收方必须用 SA_SIGINFO 标志安装处理函数，才能拿到附带数据：

struct sigaction act;
sigemptyset(&act.sa_mask);
act.sa_sigaction = handler; // 三参数处理函数
act.sa_flags = SA_RESTART | SA_SIGINFO; // SA_SIGINFO 是关键
sigaction(SIGRTMIN + 5, &act, nullptr);

处理函数中 siginfo_t 的关键字段（实时信号）：

7.4 实时信号排队上限

Linux 2.6.8+ 使用 RLIMIT_SIGPENDING 资源限制，控制每个真实用户 ID 下所有进程可排队的信号总数。队列满时 sigqueue() 返回 EAGAIN。

八、sigsuspend()：原子解除屏蔽并等待

8.1 为什么需要 sigsuspend？

朴素写法存在竞态条件（race condition）：

错误的写法（有 bug）：
sigprocmask(SIG_SETMASK, &prevMask, NULL); // 解除屏蔽
↑
如果信号在这里到来…
处理函数被调用并返回
↓
pause(); // 等待——但信号已经错过了！永久阻塞！

问题：解除屏蔽和 pause() 之间有一个窗口，如果信号恰好在这个窗口里到来，pause() 就会永远等待"下一次"信号。

8.2 sigsuspend() 的原子性

sigsuspend() 把"替换屏蔽字 + 挂起等待"做成原子操作：

#include <signal.h>
int sigsuspend(const sigset_t *mask);
// 正常情况下返回 -1，errno=EINTR

等价于以下三步的原子版本：

sigprocmask(SIG_SETMASK, mask, &prevMask)

→

原子

pause()

→

信号处理函数返回

sigprocmask(SIG_SETMASK, &prevMask, NULL)

\\text{sigprocmask(SIG\\_SETMASK, mask, \\&prevMask)} \\xrightarrow{\\text{原子}} \\text{pause()} \\xrightarrow{\\text{信号处理函数返回}} \\text{sigprocmask(SIG\\_SETMASK, \\&prevMask, NULL)}

sigprocmask(SIG_SETMASK, mask, &prevMask)原子

​pause()信号处理函数返回

​sigprocmask(SIG_SETMASK, &prevMask, NULL) 即：用 mask 临时替换当前屏蔽字 → 挂起等待信号 → 处理函数返回后自动恢复原屏蔽字。 正确的使用模式：

关键区 → 保持信号屏蔽（阻塞）
↓
sigsuspend(原来的屏蔽字) ← 原子解除屏蔽并等待
↓（处理函数返回后）
屏蔽字自动恢复为阻塞状态 ← 回到关键区保护

九、sigwaitinfo()：同步等待信号

9.1 与 sigsuspend 的区别

sigsuspend() 需要编写处理函数，sigwaitinfo() 则完全不需要处理函数，直接同步地"取走"一个信号：

#define _POSIX_C_SOURCE 199309
#include <signal.h>
int sigwaitinfo(const sigset_t *set, siginfo_t *info);
// 成功返回信号编号，失败返回 -1
int sigtimedwait(const sigset_t *set, siginfo_t *info,
const struct timespec *timeout);
// timeout 两字段均为 0：立即轮询（不阻塞）
// timeout 为 NULL：等同于 sigwaitinfo()
// 超时返回 -1，errno=EAGAIN

使用前提：必须先用 sigprocmask() 屏蔽 set 中的信号，否则信号可能在 sigwaitinfo() 调用前就被按默认方式处理了。

9.2 sigwaitinfo 的优势

sigsuspend + 处理函数 vs sigwaitinfo
─────────────────────────────────────
需要编写处理函数 不需要处理函数
处理函数在信号栈执行 直接在主程序流中处理
速度较慢 速度更快（无函数调用开销）
受异步安全函数限制 无此限制

十、signalfd()：通过文件描述符读取信号

10.1 概念

Linux 2.6.22 引入的非标准系统调用。把信号"变成"可用 read() 读取的文件描述符，从而可以用 select()、poll()、epoll 来监控信号，与 I/O 事件统一处理。

#include <sys/signalfd.h>
int signalfd(int fd, const sigset_t *mask, int flags);
// fd=-1: 创建新 fd
// fd=已有: 更新 mask
// flags: SFD_CLOEXEC, SFD_NONBLOCK（2.6.27+）
// 成功返回文件描述符，失败返回 -1

读取到的数据格式：signalfd_siginfo 结构体，字段与 siginfo_t 类似（字段名以 ssi_ 开头）。

10.2 使用步骤

#mermaid-svg-UmpXqhC343a1TRER{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-UmpXqhC343a1TRER .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-UmpXqhC343a1TRER .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-UmpXqhC343a1TRER .error-icon{fill:#552222;}#mermaid-svg-UmpXqhC343a1TRER .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-UmpXqhC343a1TRER .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-UmpXqhC343a1TRER .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-UmpXqhC343a1TRER .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-UmpXqhC343a1TRER .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-UmpXqhC343a1TRER .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-UmpXqhC343a1TRER .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-UmpXqhC343a1TRER .marker{fill:#333333;stroke:#333333;}#mermaid-svg-UmpXqhC343a1TRER .marker.cross{stroke:#333333;}#mermaid-svg-UmpXqhC343a1TRER svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-UmpXqhC343a1TRER p{margin:0;}#mermaid-svg-UmpXqhC343a1TRER .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-UmpXqhC343a1TRER .cluster-label text{fill:#333;}#mermaid-svg-UmpXqhC343a1TRER .cluster-label span{color:#333;}#mermaid-svg-UmpXqhC343a1TRER .cluster-label span p{background-color:transparent;}#mermaid-svg-UmpXqhC343a1TRER .label text,#mermaid-svg-UmpXqhC343a1TRER span{fill:#333;color:#333;}#mermaid-svg-UmpXqhC343a1TRER .node rect,#mermaid-svg-UmpXqhC343a1TRER .node circle,#mermaid-svg-UmpXqhC343a1TRER .node ellipse,#mermaid-svg-UmpXqhC343a1TRER .node polygon,#mermaid-svg-UmpXqhC343a1TRER .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-UmpXqhC343a1TRER .rough-node .label text,#mermaid-svg-UmpXqhC343a1TRER .node .label text,#mermaid-svg-UmpXqhC343a1TRER .image-shape .label,#mermaid-svg-UmpXqhC343a1TRER .icon-shape .label{text-anchor:middle;}#mermaid-svg-UmpXqhC343a1TRER .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-UmpXqhC343a1TRER .rough-node .label,#mermaid-svg-UmpXqhC343a1TRER .node .label,#mermaid-svg-UmpXqhC343a1TRER .image-shape .label,#mermaid-svg-UmpXqhC343a1TRER .icon-shape .label{text-align:center;}#mermaid-svg-UmpXqhC343a1TRER .node.clickable{cursor:pointer;}#mermaid-svg-UmpXqhC343a1TRER .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-UmpXqhC343a1TRER .arrowheadPath{fill:#333333;}#mermaid-svg-UmpXqhC343a1TRER .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-UmpXqhC343a1TRER .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-UmpXqhC343a1TRER .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-UmpXqhC343a1TRER .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-UmpXqhC343a1TRER .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-UmpXqhC343a1TRER .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-UmpXqhC343a1TRER .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-UmpXqhC343a1TRER .cluster text{fill:#333;}#mermaid-svg-UmpXqhC343a1TRER .cluster span{color:#333;}#mermaid-svg-UmpXqhC343a1TRER div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-UmpXqhC343a1TRER .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-UmpXqhC343a1TRER rect.text{fill:none;stroke-width:0;}#mermaid-svg-UmpXqhC343a1TRER .icon-shape,#mermaid-svg-UmpXqhC343a1TRER .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-UmpXqhC343a1TRER .icon-shape p,#mermaid-svg-UmpXqhC343a1TRER .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-UmpXqhC343a1TRER .icon-shape .label rect,#mermaid-svg-UmpXqhC343a1TRER .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-UmpXqhC343a1TRER .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-UmpXqhC343a1TRER .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-UmpXqhC343a1TRER :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

1. 构建信号集 mask（要监控的信号）

2. sigprocmask()屏蔽 mask 中的信号（防止被默认处理）

3. signalfd(-1, mask, 0)创建 signalfd 文件描述符

4. read(sfd, &fdsi, sizeof(fdsi))阻塞读取，直到信号到来可读多个 signalfd_siginfo

5. 处理信号信息close(sfd) 释放资源

10.3 signalfd 的优势场景

signalfd 最大的优势：可以把信号监控统一进 I/O 多路复用：

传统方式（自管道技巧）：
信号处理函数 → write 一个字节到管道写端
主循环 select/poll 监控管道读端
signalfd 方式：
signalfd() 创建 fd
主循环 select/poll 直接监控 signalfd fd
（更简洁，无需处理函数）

十一、信号与 IPC 的比较

信号作为 IPC 机制的局限性：

结论：信号不适合作为 IPC 机制，更适合用于：进程同步、事件通知、作业控制、定时器到期通知。

十二、signal() 的可移植性问题与实现

12.1 旧版 signal() 的"不可靠"语义

早期 UNIX 的 signal() 存在两个问题（类似 SA_RESETHAND + SA_NODEFER）：

12.2 用 sigaction() 实现 signal()

// signal_impl.cpp
// 展示如何用 sigaction 实现 signal()，明确语义
#include <csignal>
typedef void (*sighandler_t)(int);
// 现代语义（默认）：SA_RESTART，处理期间屏蔽同一信号，不自动重置
// 旧语义（-DOLD_SIGNAL）：SA_RESETHAND | SA_NODEFER，不重启系统调用
sighandler_t my_signal(int sig, sighandler_t handler) {
struct sigaction newDisp, prevDisp;
newDisp.sa_handler = handler;
sigemptyset(&newDisp.sa_mask);
#ifdef OLD_SIGNAL
// 旧（不可靠）语义：
// SA_RESETHAND: 处理函数调用后自动重置为 SIG_DFL
// SA_NODEFER: 处理函数执行期间不屏蔽本信号（可递归）
newDisp.sa_flags = SA_RESETHAND | SA_NODEFER;
#else
// 现代（可靠）语义：
// SA_RESTART: 被信号中断的系统调用自动重启
// 默认：处理期间屏蔽同一信号，处理函数不被重置
newDisp.sa_flags = SA_RESTART;
#endif
if (sigaction(sig, &newDisp, &prevDisp) == –1)
return SIG_ERR;
return prevDisp.sa_handler;
}

十三、完整示例代码（C++）

示例一：发送和接收实时信号（附带数据）

// rtsig_sender.cpp — 发送实时信号
// 编译: g++ -o rtsig_sender rtsig_sender.cpp
// 用法: ./rtsig_sender <目标PID> <信号偏移0~31> <整数数据> [发送次数]
#include <csignal> // sigqueue, union sigval
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
int main(int argc, char* argv[]) {
if (argc < 4) {
fprintf(stderr, "用法: %s pid sig_offset data [count]\\n", argv[0]);
fprintf(stderr, " sig_offset: 0~31，实际信号为 SIGRTMIN+sig_offset\\n");
return EXIT_FAILURE;
}
pid_t targetPid = (pid_t)atol(argv[1]);
int sigOffset = atoi(argv[2]);
int sigData = atoi(argv[3]);
int count = (argc > 4) ? atoi(argv[4]) : 1;
int sig = SIGRTMIN + sigOffset;
if (sig > SIGRTMAX) {
fprintf(stderr, "信号偏移超出范围，SIGRTMAX=%d\\n", SIGRTMAX);
return EXIT_FAILURE;
}
printf("发送方 PID=%ld, UID=%ld\\n", (long)getpid(), (long)getuid());
printf("目标: PID=%ld, 信号=%d (SIGRTMIN+%d), 数据起始=%d, 次数=%d\\n",
(long)targetPid, sig, sigOffset, sigData, count);
for (int i = 0; i < count; i++) {
union sigval sv;
sv.sival_int = sigData + i; // 每次发送的数据递增
// sigqueue() 比 kill() 多一个 sigval 参数，可携带数据
// 实时信号会排队：发几次就能收几次
if (sigqueue(targetPid, sig, sv) == –1) {
if (errno == EAGAIN) {
fprintf(stderr, "信号队列已满（EAGAIN），第 %d 次发送失败\\n", i+1);
} else {
perror("sigqueue");
}
return EXIT_FAILURE;
}
printf("已发送第 %d 次，附带数据: %d\\n", i+1, sigData + i);
}
return EXIT_SUCCESS;
}

// rtsig_receiver.cpp — 接收实时信号
// 编译: g++ -o rtsig_receiver rtsig_receiver.cpp
// 用法: ./rtsig_receiver [屏蔽秒数]
// 先运行接收方，记下 PID，再运行发送方
#include <csignal>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <cerrno>
static volatile int totalCaught = 0;
static volatile sig_atomic_t done = 0;
// SA_SIGINFO 三参数处理函数
// sig: 信号编号
// si: siginfo_t 指针，包含发送方信息和附带数据
// uc: 进程上下文（通常不使用）
static void rtSigHandler(int sig, siginfo_t* si, void* uc) {
// UNSAFE: printf 不是异步信号安全函数，仅用于演示
totalCaught++;
printf("收到实时信号 %d\\n", sig);
printf(" si_code=%d (%s)\\n",
si->si_code,
si->si_code == SI_QUEUE ? "SI_QUEUE(sigqueue发送)" :
si->si_code == SI_USER ? "SI_USER(kill发送)" : "其他");
printf(" si_value=%d\\n", si->si_value.sival_int);
printf(" 来自 PID=%ld, UID=%ld\\n",
(long)si->si_pid, (long)si->si_uid);
if (sig == SIGINT || sig == SIGTERM) {
done = 1;
}
}
int main(int argc, char* argv[]) {
printf("接收方 PID: %ld\\n", (long)getpid());
// 为所有实时信号安装处理函数
struct sigaction sa;
sa.sa_sigaction = rtSigHandler;
sa.sa_flags = SA_SIGINFO; // 必须设置，才能收到 siginfo_t
sigfillset(&sa.sa_mask); // 处理函数执行期间屏蔽所有信号
for (int sig = SIGRTMIN; sig <= SIGRTMAX; sig++) {
if (sigaction(sig, &sa, nullptr) == –1) {
// 某些实时信号可能被线程库保留，忽略错误
}
}
// 同样捕获 SIGINT 和 SIGTERM 用于退出
sa.sa_flags = SA_SIGINFO;
sigaction(SIGINT, &sa, nullptr);
sigaction(SIGTERM, &sa, nullptr);
// 若提供参数，先屏蔽所有信号睡眠，期间发送方可以排队多个信号
if (argc > 1) {
int sleepSecs = atoi(argv[1]);
sigset_t blockAll;
sigfillset(&blockAll);
sigdelset(&blockAll, SIGKILL);
sigdelset(&blockAll, SIGSTOP);
sigprocmask(SIG_SETMASK, &blockAll, nullptr);
printf("屏蔽所有信号，睡眠 %d 秒（此期间请发送实时信号）…\\n", sleepSecs);
sleep(sleepSecs);
printf("睡眠结束，解除屏蔽，开始处理待决信号…\\n\\n");
// 解除屏蔽，待决的实时信号将按编号升序逐一投递
sigset_t emptyMask;
sigemptyset(&emptyMask);
sigprocmask(SIG_SETMASK, &emptyMask, nullptr);
}
// 等待信号到来
while (!done) {
pause();
}
printf("\\n共收到 %d 个实时信号\\n", totalCaught);
return EXIT_SUCCESS;
}

示例二：sigsuspend() 原子等待演示

// sigsuspend_demo.cpp
// 编译: g++ -o sigsuspend_demo sigsuspend_demo.cpp
// 演示：屏蔽 SIGINT，执行"关键区"，然后用 sigsuspend 原子等待
#include <csignal>
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
#include <ctime>
#include <cerrno>
#include <cstring>
static volatile sig_atomic_t gotSigquit = 0;
static void handler(int sig) {
// UNSAFE: 仅演示用
const char* name = (sig == SIGINT) ? "SIGINT(Ctrl+C)" : "SIGQUIT(Ctrl+\\\\)";
// 用 write 代替 printf，write 是异步信号安全的
char buf[64];
int len = snprintf(buf, sizeof(buf), "收到 %s\\n", name);
write(STDOUT_FILENO, buf, len);
if (sig == SIGQUIT) {
gotSigquit = 1;
}
}
int main() {
// 安装 SIGINT 和 SIGQUIT 的处理函数
struct sigaction sa;
sa.sa_handler = handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGINT, &sa, nullptr);
sigaction(SIGQUIT, &sa, nullptr);
// 构建要屏蔽的信号集：SIGINT + SIGQUIT
sigset_t blockMask;
sigemptyset(&blockMask);
sigaddset(&blockMask, SIGINT);
sigaddset(&blockMask, SIGQUIT);
// 屏蔽信号，保存原屏蔽字
sigset_t origMask;
sigprocmask(SIG_BLOCK, &blockMask, &origMask);
int loop = 0;
while (!gotSigquit) {
loop++;
printf("\\n=== 第 %d 次循环：开始关键区（信号已屏蔽）===\\n", loop);
// 模拟关键区：忙等 3 秒
// 此期间 Ctrl+C 会被屏蔽，信号变为待决
time_t start = time(nullptr);
while (time(nullptr) < start + 3)
; // 忙等
// 查看待决信号
sigset_t pending;
sigpending(&pending);
if (sigismember(&pending, SIGINT))
printf("SIGINT 处于待决状态（关键区期间按了 Ctrl+C）\\n");
if (sigismember(&pending, SIGQUIT))
printf("SIGQUIT 处于待决状态\\n");
printf("关键区结束，调用 sigsuspend() 原子等待信号…\\n");
// sigsuspend(origMask)：
// 1. 将屏蔽字替换为 origMask（解除对 SIGINT/SIGQUIT 的屏蔽）
// 2. 挂起进程，等待信号处理函数被调用并返回
// 3. 自动恢复为 blockMask（重新屏蔽 SIGINT/SIGQUIT）
// 全程原子，不存在竞态窗口
if (sigsuspend(&origMask) == –1 && errno != EINTR) {
perror("sigsuspend");
}
// 回到这里时，屏蔽字已自动恢复为 blockMask
}
// 恢复原屏蔽字
sigprocmask(SIG_SETMASK, &origMask, nullptr);
printf("\\n收到 SIGQUIT，退出\\n");
return EXIT_SUCCESS;
}

示例三：sigwaitinfo() 同步接收信号

// sigwaitinfo_demo.cpp
// 编译: g++ -o sigwaitinfo_demo sigwaitinfo_demo.cpp
// 用法: ./sigwaitinfo_demo [等待秒数]
// 等待秒数期间可用另一终端发送信号
#include <csignal>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <ctime>
int main(int argc, char* argv[]) {
printf("本进程 PID: %ld\\n", (long)getpid());
// 步骤1：屏蔽所有信号（除 SIGKILL/SIGSTOP）
// 这样信号不会被默认处理，而是积压为待决
sigset_t allSigs;
sigfillset(&allSigs);
if (sigprocmask(SIG_SETMASK, &allSigs, nullptr) == –1) {
perror("sigprocmask");
return EXIT_FAILURE;
}
printf("所有信号已屏蔽\\n");
// 步骤2：可选睡眠，期间可以向本进程发送信号
if (argc > 1) {
int delaySecs = atoi(argv[1]);
printf("睡眠 %d 秒（期间请发送信号）…\\n", delaySecs);
sleep(delaySecs);
printf("睡眠结束，开始处理信号\\n\\n");
}
// 步骤3：循环用 sigwaitinfo() 同步取走信号
// 不需要处理函数！直接在主程序中处理
for (;;) {
siginfo_t si;
// sigwaitinfo() 阻塞，直到 allSigs 中的某个信号到来
// 该信号从待决集中移除，不会再次投递
int sig = sigwaitinfo(&allSigs, &si);
if (sig == –1) {
perror("sigwaitinfo");
return EXIT_FAILURE;
}
// 收到 SIGINT 或 SIGTERM 时退出
if (sig == SIGINT || sig == SIGTERM) {
printf("收到终止信号 %d，退出\\n", sig);
return EXIT_SUCCESS;
}
printf("收到信号: %d (%s)\\n", sig, strsignal(sig));
printf(" si_code=%d (%s)\\n",
si.si_code,
si.si_code == SI_QUEUE ? "SI_QUEUE" :
si.si_code == SI_USER ? "SI_USER" : "其他");
printf(" si_value=%d\\n", si.si_value.sival_int);
printf(" 发送方 PID=%ld, UID=%ld\\n\\n",
(long)si.si_pid, (long)si.si_uid);
}
}

示例四：signalfd() 通过文件描述符读取信号

// signalfd_demo.cpp
// 编译: g++ -o signalfd_demo signalfd_demo.cpp
// 用法: ./signalfd_demo <信号编号> [信号编号2 …]
// 示例: ./signalfd_demo 10 12 （监控 SIGUSR1 和 SIGUSR2）
#include <sys/signalfd.h> // signalfd, signalfd_siginfo
#include <csignal>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
int main(int argc, char* argv[]) {
if (argc < 2) {
fprintf(stderr, "用法: %s <信号编号> [信号编号2…]\\n", argv[0]);
return EXIT_FAILURE;
}
printf("本进程 PID: %ld\\n", (long)getpid());
// 步骤1：构建要监控的信号集
sigset_t mask;
sigemptyset(&mask);
for (int i = 1; i < argc; i++) {
int sig = atoi(argv[i]);
sigaddset(&mask, sig);
printf("监控信号: %d (%s)\\n", sig, strsignal(sig));
}
// 步骤2：屏蔽这些信号，防止它们被默认处理
// 必须在 signalfd() 之前调用
if (sigprocmask(SIG_BLOCK, &mask, nullptr) == –1) {
perror("sigprocmask");
return EXIT_FAILURE;
}
// 步骤3：创建 signalfd 文件描述符
// 参数 -1 表示创建新 fd；flags=0（或 SFD_NONBLOCK, SFD_CLOEXEC）
int sfd = signalfd(–1, &mask, 0);
if (sfd == –1) {
perror("signalfd");
return EXIT_FAILURE;
}
printf("signalfd 创建成功，fd=%d\\n\\n");
printf("等待信号中（可用 kill -<信号> %ld 发送）…\\n", (long)getpid());
// 步骤4：循环从 signalfd 读取信号
for (;;) {
struct signalfd_siginfo fdsi;
// read() 阻塞，直到有信号到来
// 每次 read 可返回多个 signalfd_siginfo（若缓冲区够大）
ssize_t s = read(sfd, &fdsi, sizeof(fdsi));
if (s != sizeof(fdsi)) {
perror("read");
return EXIT_FAILURE;
}
// 打印信号信息
printf("收到信号: %u (%s)\\n",
fdsi.ssi_signo, strsignal(fdsi.ssi_signo));
printf(" ssi_code=%d (%s)\\n",
fdsi.ssi_code,
fdsi.ssi_code == SI_QUEUE ? "SI_QUEUE" :
fdsi.ssi_code == SI_USER ? "SI_USER" : "其他");
// 仅当 SI_QUEUE 时，ssi_int 才有意义
if (fdsi.ssi_code == SI_QUEUE) {
printf(" ssi_pid=%u, ssi_int=%d\\n",
fdsi.ssi_pid, fdsi.ssi_int);
}
printf("\\n");
// 收到 SIGTERM 或 SIGINT 则退出
if (fdsi.ssi_signo == SIGTERM || fdsi.ssi_signo == SIGINT) {
printf("收到终止信号，关闭 signalfd 并退出\\n");
close(sfd); // 释放内核资源
return EXIT_SUCCESS;
}
}
}

十四、本章知识点总览

#mermaid-svg-IEucuPxdcOWDxkct{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-IEucuPxdcOWDxkct .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-IEucuPxdcOWDxkct .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-IEucuPxdcOWDxkct .error-icon{fill:#552222;}#mermaid-svg-IEucuPxdcOWDxkct .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-IEucuPxdcOWDxkct .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-IEucuPxdcOWDxkct .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-IEucuPxdcOWDxkct .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-IEucuPxdcOWDxkct .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-IEucuPxdcOWDxkct .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-IEucuPxdcOWDxkct .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-IEucuPxdcOWDxkct .marker{fill:#333333;stroke:#333333;}#mermaid-svg-IEucuPxdcOWDxkct .marker.cross{stroke:#333333;}#mermaid-svg-IEucuPxdcOWDxkct svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-IEucuPxdcOWDxkct p{margin:0;}#mermaid-svg-IEucuPxdcOWDxkct .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-IEucuPxdcOWDxkct .cluster-label text{fill:#333;}#mermaid-svg-IEucuPxdcOWDxkct .cluster-label span{color:#333;}#mermaid-svg-IEucuPxdcOWDxkct .cluster-label span p{background-color:transparent;}#mermaid-svg-IEucuPxdcOWDxkct .label text,#mermaid-svg-IEucuPxdcOWDxkct span{fill:#333;color:#333;}#mermaid-svg-IEucuPxdcOWDxkct .node rect,#mermaid-svg-IEucuPxdcOWDxkct .node circle,#mermaid-svg-IEucuPxdcOWDxkct .node ellipse,#mermaid-svg-IEucuPxdcOWDxkct .node polygon,#mermaid-svg-IEucuPxdcOWDxkct .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-IEucuPxdcOWDxkct .rough-node .label text,#mermaid-svg-IEucuPxdcOWDxkct .node .label text,#mermaid-svg-IEucuPxdcOWDxkct .image-shape .label,#mermaid-svg-IEucuPxdcOWDxkct .icon-shape .label{text-anchor:middle;}#mermaid-svg-IEucuPxdcOWDxkct .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-IEucuPxdcOWDxkct .rough-node .label,#mermaid-svg-IEucuPxdcOWDxkct .node .label,#mermaid-svg-IEucuPxdcOWDxkct .image-shape .label,#mermaid-svg-IEucuPxdcOWDxkct .icon-shape .label{text-align:center;}#mermaid-svg-IEucuPxdcOWDxkct .node.clickable{cursor:pointer;}#mermaid-svg-IEucuPxdcOWDxkct .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-IEucuPxdcOWDxkct .arrowheadPath{fill:#333333;}#mermaid-svg-IEucuPxdcOWDxkct .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-IEucuPxdcOWDxkct .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-IEucuPxdcOWDxkct .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-IEucuPxdcOWDxkct .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-IEucuPxdcOWDxkct .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-IEucuPxdcOWDxkct .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-IEucuPxdcOWDxkct .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-IEucuPxdcOWDxkct .cluster text{fill:#333;}#mermaid-svg-IEucuPxdcOWDxkct .cluster span{color:#333;}#mermaid-svg-IEucuPxdcOWDxkct div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-IEucuPxdcOWDxkct .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-IEucuPxdcOWDxkct rect.text{fill:none;stroke-width:0;}#mermaid-svg-IEucuPxdcOWDxkct .icon-shape,#mermaid-svg-IEucuPxdcOWDxkct .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-IEucuPxdcOWDxkct .icon-shape p,#mermaid-svg-IEucuPxdcOWDxkct .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-IEucuPxdcOWDxkct .icon-shape .label rect,#mermaid-svg-IEucuPxdcOWDxkct .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-IEucuPxdcOWDxkct .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-IEucuPxdcOWDxkct .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-IEucuPxdcOWDxkct :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

信号高级特性

Core Dumpcore_pattern 自定义命名

特殊信号规则SIGKILL/SIGSTOP 不可屏蔽SIGCONT 与停止信号互消

睡眠状态可中断 S / 不可中断 D / 可杀 K

硬件信号不能正常 return用 siglongjmp 或 _exit

同步 vs 异步信号同步：立即投递异步：下次内核→用户切换时

实时信号排队+携带数据+有序投递sigqueue() 发送

原子等待sigsuspend() 解决竞态

同步接收sigwaitinfo/sigtimedwait无需处理函数

文件描述符接收signalfd()可与 select/poll/epoll 集成

十五、关键 API 速查

Linux 定时器与睡眠机制详解

本文对应《The Linux Programming Interface》第23章：Timers and Sleeping 目标：把每个API讲清楚，配合可运行的C++代码示例。

整体概览

本章涉及的API可以分为四个层次，从最古老到最现代：

+————————————————–+
| 层次1：经典UNIX接口（最古老） |
| alarm() / setitimer() / getitimer() |
+————————————————–+
| 层次2：睡眠接口 |
| sleep() / nanosleep() |
+————————————————–+
| 层次3：POSIX高精度时钟与定时器（POSIX.1b） |
| clock_gettime() / clock_nanosleep() |
| timer_create() / timer_settime() / timer_delete()|
+————————————————–+
| 层次4：Linux专有 timerfd（最现代） |
| timerfd_create() / timerfd_settime() |
| 可与 select/poll/epoll 配合使用 |
+————————————————–+

第一部分：间隔定时器 setitimer() 与 alarm()

1.1 setitimer() — 设置间隔定时器

概念解释

setitimer() 允许进程设置一个"倒计时器"，时间到了之后向自己发送一个信号。 它支持三种计时方式：

数据结构

itimerval 结构（定时器的设置）
┌──────────────────────────────────┐
│ it_interval （重复间隔） │ ← 每次到期后重置为这个值继续倒数
│ tv_sec (秒) │
│ tv_usec (微秒) │
├──────────────────────────────────┤
│ it_value （当前剩余时间） │ ← 多久之后第一次到期
│ tv_sec (秒) │
│ tv_usec (微秒) │
└──────────────────────────────────┘

关键规则：

• 如果 it_interval 全为 0：定时器只触发一次
• 如果 it_interval 非零：定时器周期性触发，每次到期后重置
• 每个进程只能有各一个这三种类型的定时器

定时器的运作示意

时间轴：
0s ────────────────── 1.8s ──── 2.8s ──── 3.8s ──→
↑ 设置定时器 ↑ ↑ ↑
it_value=1.8s SIGALRM SIGALRM SIGALRM
it_interval=1s (重置) (重置) (重置)

函数原型（C++中对应的头文件）

#include <sys/time.h>
// 设置定时器
// which: ITIMER_REAL / ITIMER_VIRTUAL / ITIMER_PROF
// new_value: 新的定时器设置
// old_value: 返回旧的定时器设置（不需要时传 nullptr）
int setitimer(int which,
const struct itimerval *new_value,
struct itimerval *old_value);
// 获取定时器当前状态
int getitimer(int which, struct itimerval *curr_value);

完整可运行示例

// 文件名：real_timer_demo.cpp
// 编译：g++ -o real_timer_demo real_timer_demo.cpp
// 运行：./real_timer_demo
#include <csignal> // signal, sigaction, SIGALRM
#include <sys/time.h> // setitimer, getitimer, itimerval, timeval
#include <cstdio> // printf
#include <cstdlib> // exit
#include <cstring> // memset
#include <unistd.h> // pause
// 全局标志：记录是否收到了 SIGALRM 信号
// 用 volatile sig_atomic_t 保证信号处理器中修改是安全的
static volatile sig_atomic_t g_got_alarm = 0;
// 信号处理函数
// 注意：这里只设置标志，不做复杂操作
// （复杂操作在信号处理函数里不安全，见异步信号安全章节）
static void sigalrm_handler(int sig) {
g_got_alarm = 1;
}
// 辅助函数：显示当前经过时间和定时器状态
static void display_times(const char* label, bool show_timer) {
static struct timeval start_time;
static bool initialized = false;
struct timeval now;
// 第一次调用时记录起始时间
if (!initialized) {
gettimeofday(&start_time, nullptr);
initialized = true;
}
gettimeofday(&now, nullptr);
// 计算经过的秒数（包含小数部分）
double elapsed = (now.tv_sec – start_time.tv_sec)
+ (now.tv_usec – start_time.tv_usec) / 1e6;
printf("%-8s 经过时间: %6.2f秒", label, elapsed);
if (show_timer) {
struct itimerval itv;
getitimer(ITIMER_REAL, &itv);
// 定时器剩余时间和间隔
double remaining = itv.it_value.tv_sec
+ itv.it_value.tv_usec / 1e6;
double interval = itv.it_interval.tv_sec
+ itv.it_interval.tv_usec / 1e6;
printf(" 剩余: %6.2f秒 间隔: %6.2f秒", remaining, interval);
}
printf("\\n");
}
int main() {
// 第一步：设置 SIGALRM 的信号处理函数
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sigalrm_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0; // 不设 SA_RESTART，让系统调用被信号中断
if (sigaction(SIGALRM, &sa, nullptr) == –1) {
perror("sigaction");
return 1;
}
// 第二步：设置定时器
// 第一次到期：1.8秒后
// 之后每隔：1秒触发一次
struct itimerval itv;
itv.it_value.tv_sec = 1;
itv.it_value.tv_usec = 800000; // 1.8秒
itv.it_interval.tv_sec = 1;
itv.it_interval.tv_usec = 0; // 间隔1秒
display_times("START:", false); // 显示起始状态
if (setitimer(ITIMER_REAL, &itv, nullptr) == –1) {
perror("setitimer");
return 1;
}
// 第三步：主循环，持续消耗CPU时间
// 每消耗约0.5秒CPU时间就检查一次定时器状态
int signal_count = 0;
const int MAX_SIGNALS = 3; // 最多处理3次信号后退出
// 记录上一次检查的CPU时间
clock_t prev_clock = clock();
for (;;) {
// 内层循环：消耗约0.5秒CPU时间
while (((clock() – prev_clock) * 10 / CLOCKS_PER_SEC) < 5) {
// 如果收到了信号
if (g_got_alarm) {
g_got_alarm = 0;
display_times("ALARM:", true);
signal_count++;
if (signal_count >= MAX_SIGNALS) {
printf("收到了 %d 次定时器信号，程序退出\\n", MAX_SIGNALS);
exit(EXIT_SUCCESS);
}
}
}
// 消耗了0.5秒，打印一次状态
prev_clock = clock();
display_times("Main:", true);
}
return 0;
}

https://godbolt.org/z/4svr8o84E 运行输出示例：

START: 经过时间: 0.00秒
Main: 经过时间: 0.50秒 剩余: 1.30秒 间隔: 1.00秒
Main: 经过时间: 1.00秒 剩余: 0.80秒 间隔: 1.00秒
Main: 经过时间: 1.50秒 剩余: 0.30秒 间隔: 1.00秒
ALARM: 经过时间: 1.80秒 剩余: 1.00秒 间隔: 1.00秒
Main: 经过时间: 2.00秒 剩余: 0.80秒 间隔: 1.00秒
…
收到了 3 次定时器信号，程序退出

1.2 alarm() — 更简单的一次性定时器

alarm() 是 setitimer() 的简化版，只能设置一次性的实时定时器（ITIMER_REAL）。

alarm(5)
↓
5秒后 → 发送 SIGALRM → 若没有处理器则进程终止

#include <unistd.h>
// seconds秒后发送 SIGALRM
// 返回：上一个定时器的剩余秒数（没有则返回0）
// alarm(0) 取消已有定时器
unsigned int alarm(unsigned int seconds);

alarm() 最常见的用法：为阻塞操作设置超时

// 使用 alarm() 为 read() 设置超时
// 文件名：timed_read_demo.cpp
// 编译：g++ -o timed_read_demo timed_read_demo.cpp
// 运行：./timed_read_demo 然后等待，或输入内容
#include <csignal>
#include <unistd.h>
#include <cstdio>
#include <cstring>
#include <cerrno>
// 信号处理函数（什么都不做，只是打断系统调用）
static void handler(int sig) {
// 空函数体：仅仅用于打断 read() 系统调用
// 当信号到来时，read() 会返回 -1，errno = EINTR
}
int main() {
const int TIMEOUT_SECS = 5; // 超时时间：5秒
char buf[200];
// 设置信号处理函数
// 注意：不设 SA_RESTART，这样信号会打断 read()
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0; // 关键：不加 SA_RESTART
if (sigaction(SIGALRM, &sa, nullptr) == –1) {
perror("sigaction");
return 1;
}
printf("请在 %d 秒内输入内容（否则超时）：\\n", TIMEOUT_SECS);
// 设置定时器
alarm(TIMEOUT_SECS);
// 执行可能阻塞的系统调用
ssize_t n = read(STDIN_FILENO, buf, sizeof(buf) – 1);
// 保存 errno（因为 alarm(0) 可能改变它）
int saved_errno = errno;
// 取消定时器（以防 read() 在超时前返回了）
alarm(0);
// 还原 errno
errno = saved_errno;
if (n == –1) {
if (errno == EINTR) {
printf("超时！read() 被信号中断\\n");
} else {
perror("read");
}
} else {
buf[n] = '\\0';
printf("成功读取 %ld 字节：%s\\n", (long)n, buf);
}
return 0;
}

注意竞争条件： 在 alarm() 调用完成之后、read() 开始之前，如果定时器恰好在这极短的时间内触发，read() 就不会被中断。 这种情况极少发生，但理论上存在。更安全的替代方案是使用 select()/poll() 的超时参数。

第二部分：睡眠函数

2.1 sleep() — 低精度睡眠（秒级）

#include <unistd.h>
// 睡眠 seconds 秒
// 返回：0（正常完成）或剩余未睡眠的秒数（被信号打断）
unsigned int sleep(unsigned int seconds);

注意： 在 Linux 上，sleep() 内部用 nanosleep() 实现，不会与 alarm() 冲突。但在其他 UNIX 系统上，sleep() 可能用 alarm() 实现，混用会有问题。

2.2 nanosleep() — 高精度睡眠（纳秒级）

nanosleep() 比 sleep() 更精确，精度可达纳秒（但实际精度受内核时钟粒度限制）。

#define _POSIX_C_SOURCE 199309
#include <time.h>
// request: 想睡多久
// remain: 如果被信号打断，剩余未睡的时间写到这里
// 返回：0（正常完成），-1（出错或被打断，errno=EINTR）
int nanosleep(const struct timespec *request, struct timespec *remain);

timespec 结构体：

struct timespec {
time_t tv_sec; // 秒
long tv_nsec; // 纳秒（必须在 0 ~ 999,999,999 之间）
};

精度关系：

1

秒

=

10

3

毫秒

=

10

6

微秒

=

10

9

纳秒

1\\text{秒} = 10^3\\text{毫秒} = 10^6\\text{微秒} = 10^9\\text{纳秒}

1秒=103毫秒=106微秒=109纳秒

完整示例：可被信号打断并重启的睡眠

// 文件名：nanosleep_demo.cpp
// 编译：g++ -o nanosleep_demo nanosleep_demo.cpp
// 运行：./nanosleep_demo 10 0
// （睡10秒，按 Ctrl+C 可打断，会自动重启继续睡）
#define _POSIX_C_SOURCE 199309
#include <ctime> // nanosleep, timespec, clock_gettime
#include <csignal> // sigaction, SIGINT
#include <sys/time.h> // gettimeofday
#include <cstdio> // printf
#include <cstdlib> // atol, exit
#include <cstring> // memset
#include <cerrno> // errno, EINTR
// SIGINT 信号处理函数（什么都不做，只是打断 nanosleep）
static void sigint_handler(int sig) {
// 空函数体：信号到来时 nanosleep() 返回 -1，errno=EINTR
}
int main(int argc, char* argv[]) {
if (argc != 3) {
printf("用法：%s <秒> <纳秒>\\n", argv[0]);
printf("例如：%s 10 0 （睡10秒）\\n", argv[0]);
return 1;
}
// 设置睡眠时间
struct timespec request;
request.tv_sec = atol(argv[1]);
request.tv_nsec = atol(argv[2]);
// 注册 SIGINT 处理函数，使得 Ctrl+C 可以打断 nanosleep
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sigint_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
if (sigaction(SIGINT, &sa, nullptr) == –1) {
perror("sigaction");
return 1;
}
// 记录开始时间
struct timeval start;
gettimeofday(&start, nullptr);
printf("开始睡眠 %ld 秒 %ld 纳秒\\n", request.tv_sec, request.tv_nsec);
printf("（按 Ctrl+C 打断，会自动重启继续睡）\\n\\n");
// 循环调用 nanosleep，如果被信号打断就用剩余时间重启
for (;;) {
struct timespec remain;
int ret = nanosleep(&request, &remain);
// 计算已经睡了多久
struct timeval now;
gettimeofday(&now, nullptr);
double elapsed = (now.tv_sec – start.tv_sec)
+ (now.tv_usec – start.tv_usec) / 1e6;
printf("已睡眠: %.6f 秒\\n", elapsed);
if (ret == 0) {
// nanosleep 正常完成
break;
}
if (errno != EINTR) {
// 其他错误
perror("nanosleep");
return 1;
}
// 被信号打断（EINTR），用剩余时间重新睡
printf("被信号打断！剩余: %ld.%09ld 秒，继续睡…\\n",
remain.tv_sec, remain.tv_nsec);
// 用剩余时间作为下次请求
request = remain;
}
printf("睡眠完成！\\n");
return 0;
}

高频信号的问题： 如果信号来得非常频繁（比软件时钟粒度还快），每次重启 nanosleep() 都会有舍入误差（remain 向上取整到时钟粒度的倍数），导致实际睡眠时间越来越长。 解决方案：用 clock_nanosleep() 加 TIMER_ABSTIME（绝对时间），见下文。

第三部分：POSIX 高精度时钟 API

3.1 时钟类型

Linux 支持多种时钟，用 clockid_t 标识：

CLOCK_REALTIME vs CLOCK_MONOTONIC 的选择：

CLOCK_REALTIME：
2024-01-01 00:00:00
2024-01-01 00:00:01
(NTP调整) ← 可能突然跳变！
2024-01-01 00:00:00.5 ← 回拨了！
CLOCK_MONOTONIC：
0s
1s
2s
3s ← 永远单调增加，不受NTP影响

3.2 获取和设置时钟

#define _POSIX_C_SOURCE 199309
#include <time.h>
// 获取时钟当前值
// clockid: 时钟类型
// tp: 返回时间值
int clock_gettime(clockid_t clockid, struct timespec *tp);
// 获取时钟分辨率（精度）
int clock_getres(clockid_t clockid, struct timespec *res);
// 设置时钟（需要 CAP_SYS_TIME 权限，只能设置 CLOCK_REALTIME）
int clock_settime(clockid_t clockid, const struct timespec *tp);

3.3 clock_nanosleep() — 高精度睡眠（支持绝对时间）

#define _XOPEN_SOURCE 600
#include <time.h>
// clockid: 使用哪个时钟
// flags: 0（相对时间）或 TIMER_ABSTIME（绝对时间）
// request: 睡到什么时候（相对或绝对）
// remain: 剩余时间（只在相对时间模式下有效）
int clock_nanosleep(clockid_t clockid, int flags,
const struct timespec *request,
struct timespec *remain);

关键优势：TIMER_ABSTIME 模式

相对时间模式的问题：
current_time → +睡眠时间 → 目标时间
但如果中间被打断了，重启时会有误差积累
绝对时间模式的解决方案：
直接指定目标时间点，不管被打断多少次，
重启都用同一个目标时间，不会有误差积累！

完整示例：精确睡到某个绝对时间点

// 文件名：clock_nanosleep_demo.cpp
// 编译：g++ -o clock_nanosleep_demo clock_nanosleep_demo.cpp -lrt
// 运行：./clock_nanosleep_demo
#define _POSIX_C_SOURCE 200112L
#include <ctime> // clock_gettime, clock_nanosleep, CLOCK_REALTIME, TIMER_ABSTIME
#include <cstdio> // printf
#include <cstring> // memset
#include <cerrno> // errno, EINTR
int main() {
struct timespec target;
// 获取当前时间
if (clock_gettime(CLOCK_REALTIME, &target) == –1) {
perror("clock_gettime");
return 1;
}
// 目标时间 = 当前时间 + 20秒
target.tv_sec += 20;
printf("当前时间：%ld.%09ld\\n", target.tv_sec – 20, target.tv_nsec);
printf("目标时间：%ld.%09ld（20秒后）\\n", target.tv_sec, target.tv_nsec);
printf("开始睡眠…\\n");
// 用绝对时间模式睡眠
// 好处：即使被信号打断多次，重启时用同一个目标时间，不会累积误差
for (;;) {
int ret = clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &target, nullptr);
if (ret == 0) {
// 成功睡到目标时间
printf("到达目标时间！\\n");
break;
} else if (ret == EINTR) {
// 被信号打断，重新用同一个 target 继续睡
// 注意：TIMER_ABSTIME 模式下不需要更新 target！
printf("被打断，重新睡到目标时间…\\n");
} else {
// 其他错误
perror("clock_nanosleep");
return 1;
}
}
return 0;
}

第四部分：POSIX 间隔定时器（高级版 setitimer）

4.1 为什么需要 POSIX 定时器？

setitimer() 的局限性：

setitimer 的问题：
1. 每种类型只能有一个定时器（REAL/VIRTUAL/PROF 各一个）
2. 通知方式只有信号
3. 无法检测"超时溢出"（错过了几次？）
4. 精度只到微秒
POSIX timer 的改进：
1. 可以创建任意多个定时器
2. 通知方式可以是：信号、线程函数
3. 提供超时溢出计数
4. 精度到纳秒

4.2 POSIX 定时器的生命周期

#mermaid-svg-GFSLR6DDN2r85rue{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-GFSLR6DDN2r85rue .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-GFSLR6DDN2r85rue .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-GFSLR6DDN2r85rue .error-icon{fill:#552222;}#mermaid-svg-GFSLR6DDN2r85rue .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-GFSLR6DDN2r85rue .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-GFSLR6DDN2r85rue .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-GFSLR6DDN2r85rue .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-GFSLR6DDN2r85rue .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-GFSLR6DDN2r85rue .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-GFSLR6DDN2r85rue .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-GFSLR6DDN2r85rue .marker{fill:#333333;stroke:#333333;}#mermaid-svg-GFSLR6DDN2r85rue .marker.cross{stroke:#333333;}#mermaid-svg-GFSLR6DDN2r85rue svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-GFSLR6DDN2r85rue p{margin:0;}#mermaid-svg-GFSLR6DDN2r85rue .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-GFSLR6DDN2r85rue .cluster-label text{fill:#333;}#mermaid-svg-GFSLR6DDN2r85rue .cluster-label span{color:#333;}#mermaid-svg-GFSLR6DDN2r85rue .cluster-label span p{background-color:transparent;}#mermaid-svg-GFSLR6DDN2r85rue .label text,#mermaid-svg-GFSLR6DDN2r85rue span{fill:#333;color:#333;}#mermaid-svg-GFSLR6DDN2r85rue .node rect,#mermaid-svg-GFSLR6DDN2r85rue .node circle,#mermaid-svg-GFSLR6DDN2r85rue .node ellipse,#mermaid-svg-GFSLR6DDN2r85rue .node polygon,#mermaid-svg-GFSLR6DDN2r85rue .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-GFSLR6DDN2r85rue .rough-node .label text,#mermaid-svg-GFSLR6DDN2r85rue .node .label text,#mermaid-svg-GFSLR6DDN2r85rue .image-shape .label,#mermaid-svg-GFSLR6DDN2r85rue .icon-shape .label{text-anchor:middle;}#mermaid-svg-GFSLR6DDN2r85rue .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-GFSLR6DDN2r85rue .rough-node .label,#mermaid-svg-GFSLR6DDN2r85rue .node .label,#mermaid-svg-GFSLR6DDN2r85rue .image-shape .label,#mermaid-svg-GFSLR6DDN2r85rue .icon-shape .label{text-align:center;}#mermaid-svg-GFSLR6DDN2r85rue .node.clickable{cursor:pointer;}#mermaid-svg-GFSLR6DDN2r85rue .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-GFSLR6DDN2r85rue .arrowheadPath{fill:#333333;}#mermaid-svg-GFSLR6DDN2r85rue .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-GFSLR6DDN2r85rue .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-GFSLR6DDN2r85rue .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-GFSLR6DDN2r85rue .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-GFSLR6DDN2r85rue .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-GFSLR6DDN2r85rue .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-GFSLR6DDN2r85rue .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-GFSLR6DDN2r85rue .cluster text{fill:#333;}#mermaid-svg-GFSLR6DDN2r85rue .cluster span{color:#333;}#mermaid-svg-GFSLR6DDN2r85rue div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-GFSLR6DDN2r85rue .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-GFSLR6DDN2r85rue rect.text{fill:none;stroke-width:0;}#mermaid-svg-GFSLR6DDN2r85rue .icon-shape,#mermaid-svg-GFSLR6DDN2r85rue .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-GFSLR6DDN2r85rue .icon-shape p,#mermaid-svg-GFSLR6DDN2r85rue .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-GFSLR6DDN2r85rue .icon-shape .label rect,#mermaid-svg-GFSLR6DDN2r85rue .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-GFSLR6DDN2r85rue .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-GFSLR6DDN2r85rue .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-GFSLR6DDN2r85rue :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

发送信号

调用函数

不通知

timer_create创建定时器

timer_settime启动定时器

定时器到期

SIGEV_SIGNAL信号通知

SIGEV_THREAD线程通知

SIGEV_NONE手动查询

timer_gettime查询状态

timer_settime停止定时器

timer_delete删除定时器

4.3 创建定时器：timer_create()

#include <signal.h>
#include <time.h>
// 创建一个新的 POSIX 定时器
// clockid: 使用哪个时钟（CLOCK_REALTIME 等）
// evp: 定时器到期时如何通知（NULL表示默认发送SIGALRM）
// timerid: 返回定时器的ID（句柄）
int timer_create(clockid_t clockid,
struct sigevent *evp,
timer_t *timerid);

sigevent 结构体详解：

struct sigevent {
int sigev_notify; // 通知方式
int sigev_signo; // 发送哪个信号（SIGEV_SIGNAL时用）
union sigval sigev_value; // 附带数据（传给信号处理函数）
// …（线程通知相关字段）
};
union sigval {
int sival_int; // 整数附带数据
void *sival_ptr; // 指针附带数据（常用于传定时器ID）
};

通知方式对比：

4.4 启动/停止定时器：timer_settime()

#include <time.h>
// 设置定时器的触发时间和间隔
// timerid: timer_create() 返回的ID
// flags: 0（相对时间）或 TIMER_ABSTIME（绝对时间）
// value: 新的定时器设置
// old_value: 返回旧的设置（不需要时传 nullptr）
int timer_settime(timer_t timerid, int flags,
const struct itimerspec *value,
struct itimerspec *old_value);

itimerspec 与之前的 itimerval 类似，只是精度更高：

struct itimerspec {
struct timespec it_interval; // 重复间隔（秒+纳秒）
struct timespec it_value; // 第一次触发时间（秒+纳秒）
};

4.5 通知溢出（Timer Overrun）

什么是溢出？

定时器每秒触发一次，但进程被挂起了3秒：
时刻0：触发 → 排队等待
时刻1：触发 → 信号未处理，溢出！
时刻2：触发 → 信号未处理，溢出！
时刻3：进程恢复，收到信号，overrun_count = 2

获取溢出计数：

#include <time.h>
// 返回从上次信号处理到现在，定时器又额外触发了几次
// 如果只触发了一次（正常情况），返回0
int timer_getoverrun(timer_t timerid);

也可以直接从 siginfo_t 的 si_overrun 字段读取（Linux扩展，无需系统调用）。

4.6 完整示例：使用信号通知的 POSIX 定时器

// 文件名：posix_timer_signal_demo.cpp
// 编译：g++ -o posix_timer_signal_demo posix_timer_signal_demo.cpp -lrt
// 运行：./posix_timer_signal_demo
#define _POSIX_C_SOURCE 199309
#include <csignal> // sigaction, siginfo_t, sigevent, SIGRTMAX
#include <ctime> // timer_create, timer_settime, timer_getoverrun
#include <cstdio> // printf
#include <cstdlib> // exit
#include <cstring> // memset
#include <unistd.h> // pause
// 使用实时信号（SIGRTMAX），避免与 SIGALRM 冲突
// 实时信号比标准信号更可靠（可排队）
#define TIMER_SIG SIGRTMAX
// 信号处理函数
// 参数 si 包含定时器相关的详细信息
static void timer_handler(int sig, siginfo_t *si, void *uc) {
// 从 sigval 中获取定时器ID（我们在创建时设置了 sival_ptr = &timerid）
timer_t *tid_ptr = (timer_t*)si->si_value.sival_ptr;
printf("收到信号 %d\\n", sig);
printf(" 定时器ID = %ld\\n", (long)*tid_ptr);
printf(" 溢出次数 = %d\\n", timer_getoverrun(*tid_ptr));
}
int main() {
timer_t timerid;
// 第一步：设置信号处理函数
// 必须用 SA_SIGINFO，这样才能收到 siginfo_t 参数
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_flags = SA_SIGINFO; // 使用带附加信息的处理函数
sa.sa_sigaction = timer_handler;
sigemptyset(&sa.sa_mask);
if (sigaction(TIMER_SIG, &sa, nullptr) == –1) {
perror("sigaction");
return 1;
}
// 第二步：配置通知方式
struct sigevent sev;
memset(&sev, 0, sizeof(sev));
sev.sigev_notify = SIGEV_SIGNAL; // 使用信号通知
sev.sigev_signo = TIMER_SIG; // 发送这个信号
// sival_ptr 传递定时器ID的地址，这样信号处理函数能知道是哪个定时器触发的
sev.sigev_value.sival_ptr = &timerid;
// 第三步：创建定时器（使用实时时钟）
if (timer_create(CLOCK_REALTIME, &sev, &timerid) == –1) {
perror("timer_create");
return 1;
}
printf("定时器已创建，ID = %ld\\n", (long)timerid);
// 第四步：启动定时器
// 初始值：2秒后第一次触发
// 间隔：之后每5秒触发一次
struct itimerspec ts;
ts.it_value.tv_sec = 2; // 2秒后第一次触发
ts.it_value.tv_nsec = 0;
ts.it_interval.tv_sec = 5; // 之后每5秒触发
ts.it_interval.tv_nsec = 0;
if (timer_settime(timerid, 0, &ts, nullptr) == –1) {
perror("timer_settime");
timer_delete(timerid);
return 1;
}
printf("定时器已启动：2秒后第一次触发，之后每5秒触发\\n");
printf("按 Ctrl+C 退出\\n\\n");
// 第五步：等待信号（pause 会在收到任何信号时返回）
for (;;) {
pause(); // 挂起等待信号
}
// 第六步：清理（实际上不会到这里，因为 Ctrl+C 会终止程序）
timer_delete(timerid);
return 0;
}

4.7 完整示例：使用线程函数通知的 POSIX 定时器

// 文件名：posix_timer_thread_demo.cpp
// 编译：g++ -o posix_timer_thread_demo posix_timer_thread_demo.cpp -lrt -lpthread
// 运行：./posix_timer_thread_demo
#define _POSIX_C_SOURCE 199309
#include <csignal> // sigevent, SIGEV_THREAD
#include <ctime> // timer_create, timer_settime, timer_getoverrun
#include <pthread.h> // pthread_mutex_t, pthread_cond_t
#include <cstdio> // printf
#include <cstdlib> // exit
#include <cstring> // memset
#include <unistd.h> // sleep
// 互斥锁和条件变量，用于线程间同步
static pthread_mutex_t g_mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t g_cond = PTHREAD_COND_INITIALIZER;
// 记录总触发次数（包含溢出）
static int g_expire_count = 0;
// 定时器到期时，系统会在新线程中调用这个函数
// sv: timer_create 时设置的 sigev_value（我们传的是定时器ID的地址）
static void thread_notify_func(union sigval sv) {
// 获取定时器ID
timer_t *tid_ptr = (timer_t*)sv.sival_ptr;
// 获取溢出次数
int overrun = timer_getoverrun(*tid_ptr);
printf("[线程通知] 定时器ID=%ld，溢出次数=%d\\n",
(long)*tid_ptr, overrun);
// 更新全局计数（需要加锁）
pthread_mutex_lock(&g_mtx);
g_expire_count += 1 + overrun; // 这次触发 + 溢出的次数
pthread_mutex_unlock(&g_mtx);
// 通知主线程：有新的触发事件
pthread_cond_signal(&g_cond);
}
int main() {
timer_t timerid;
// 配置线程通知方式
struct sigevent sev;
memset(&sev, 0, sizeof(sev));
sev.sigev_notify = SIGEV_THREAD; // 通过线程函数通知
sev.sigev_notify_function = thread_notify_func; // 要调用的函数
sev.sigev_notify_attributes = nullptr; // 线程属性（nullptr=默认）
sev.sigev_value.sival_ptr = &timerid; // 传递定时器ID给函数
// 创建定时器
if (timer_create(CLOCK_REALTIME, &sev, &timerid) == –1) {
perror("timer_create");
return 1;
}
// 启动定时器：3秒后第一次，之后每3秒触发
struct itimerspec ts;
ts.it_value.tv_sec = 3;
ts.it_value.tv_nsec = 0;
ts.it_interval.tv_sec = 3;
ts.it_interval.tv_nsec = 0;
if (timer_settime(timerid, 0, &ts, nullptr) == –1) {
perror("timer_settime");
timer_delete(timerid);
return 1;
}
printf("定时器已启动，每3秒触发一次（通过线程函数通知）\\n");
printf("运行15秒后自动退出\\n\\n");
// 主线程：等待条件变量，每次触发时打印统计
pthread_mutex_lock(&g_mtx);
int prev_count = 0;
while (g_expire_count < 5) { // 触发5次后退出
// 等待线程通知函数发出的信号
pthread_cond_wait(&g_cond, &g_mtx);
printf("主线程：总触发次数 = %d（本次新增 %d）\\n",
g_expire_count, g_expire_count – prev_count);
prev_count = g_expire_count;
}
pthread_mutex_unlock(&g_mtx);
printf("达到5次触发，程序退出\\n");
// 清理
timer_delete(timerid);
return 0;
}

第五部分：timerfd — 通过文件描述符读取定时器事件

5.1 timerfd 的核心思想

timerfd 是 Linux 专有的 API（从 Linux 2.6.25 开始），把定时器包装成一个文件描述符。 为什么要这样设计？ 传统定时器通过信号通知，信号处理麻烦。而文件描述符可以和 select()/poll()/epoll 一起使用，能统一监听多个事件源：

传统方式（信号）：
[定时器到期] → 信号处理函数 → 复杂的异步处理
timerfd 方式：
[定时器到期] ─┐
[网络数据到来] ─┤→ epoll_wait() → 统一处理所有事件
[文件可读] ─┘

5.2 timerfd API

#include <sys/timerfd.h>
// 创建 timerfd（返回文件描述符）
// clockid: CLOCK_REALTIME 或 CLOCK_MONOTONIC
// flags: 0，或 TFD_CLOEXEC | TFD_NONBLOCK
int timerfd_create(int clockid, int flags);
// 设置/启动定时器（用法与 timer_settime 相同）
int timerfd_settime(int fd, int flags,
const struct itimerspec *new_value,
struct itimerspec *old_value);
// 查询定时器状态（用法与 timer_gettime 相同）
int timerfd_gettime(int fd, struct itimerspec *curr_value);
// 读取触发次数（必须传入 uint64_t 大小的缓冲区）
// read(fd, &num_exp, sizeof(uint64_t))
// 返回：自上次 read() 后定时器触发了几次
// 如果还没触发：阻塞等待（除非设置了 O_NONBLOCK）

与 fork/exec 的行为：

• fork() 后：子进程继承 timerfd 文件描述符，父子进程都能读取触发事件
• exec() 后：文件描述符保留（除非设置了 TFD_CLOEXEC），定时器继续运行

5.3 完整示例：timerfd 基本使用

// 文件名：timerfd_demo.cpp
// 编译：g++ -o timerfd_demo timerfd_demo.cpp
// 运行：./timerfd_demo 1:1 5
// （1秒间隔，最多读5次触发事件）
#include <sys/timerfd.h>
#include <ctime> // CLOCK_REALTIME, itimerspec, timespec
#include <cstdint> // uint64_t
#include <cstdio> // printf
#include <cstdlib> // atoi, exit
#include <cstring> // memset, strchr
#include <unistd.h> // read, close
// 解析 "秒[:纳秒][/间隔秒[:间隔纳秒]]" 格式的字符串
// 格式示例：
// "2" → 2秒后触发一次
// "2:5" → 2秒后触发，之后每5秒触发
// "1/500000000:2" → 1.5秒后触发，之后每2秒触发
static void parse_timespec_str(const char* str, struct itimerspec* ts) {
memset(ts, 0, sizeof(*ts));
// 格式：初始值 ':' 间隔值
// 每个时间值格式：秒 '/' 纳秒
char buf[256];
strncpy(buf, str, sizeof(buf) – 1);
char* colon = strchr(buf, ':');
char* slash1 = strchr(buf, '/');
if (colon) *colon = '\\0';
if (slash1 && (!colon || slash1 < colon)) *slash1 = '\\0';
// 解析初始值（秒部分）
ts->it_value.tv_sec = atoi(buf);
// 解析初始值（纳秒部分）
if (slash1 && (!colon || slash1 < colon)) {
ts->it_value.tv_nsec = atoi(slash1 + 1);
}
// 解析间隔值
if (colon) {
char* interval_str = colon + 1;
char* slash2 = strchr(interval_str, '/');
if (slash2) *slash2 = '\\0';
ts->it_interval.tv_sec = atoi(interval_str);
if (slash2) {
ts->it_interval.tv_nsec = atoi(slash2 + 1);
}
}
}
int main(int argc, char* argv[]) {
if (argc < 2) {
printf("用法：%s 时间字符串 [最大触发次数]\\n", argv[0]);
printf("例如：%s 1:1 5 （1秒触发，读5次）\\n", argv[0]);
return 1;
}
// 解析定时器参数
struct itimerspec ts;
parse_timespec_str(argv[1], &ts);
// 最大触发次数
int max_exp = (argc > 2) ? atoi(argv[2]) : 1;
// 创建 timerfd
int fd = timerfd_create(CLOCK_REALTIME, 0);
if (fd == –1) {
perror("timerfd_create");
return 1;
}
// 启动定时器（相对时间）
if (timerfd_settime(fd, 0, &ts, nullptr) == –1) {
perror("timerfd_settime");
close(fd);
return 1;
}
// 记录开始时间
struct timespec start;
clock_gettime(CLOCK_MONOTONIC, &start);
printf("定时器已启动，最多等待 %d 次触发\\n\\n", max_exp);
uint64_t total_exp = 0;
for (; total_exp < (uint64_t)max_exp;) {
// 阻塞等待定时器触发
// 读取的值是：自上次读取后定时器触发了多少次
uint64_t num_exp;
ssize_t s = read(fd, &num_exp, sizeof(uint64_t));
if (s != sizeof(uint64_t)) {
perror("read");
close(fd);
return 1;
}
total_exp += num_exp;
// 计算经过时间
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
long secs = now.tv_sec – start.tv_sec;
long nsecs = now.tv_nsec – start.tv_nsec;
if (nsecs < 0) {
secs—;
nsecs += 1000000000L;
}
printf("%ld.%03ld 秒：本次读到 %llu 次触发，累计 %llu 次\\n",
secs, nsecs / 1000000L,
(unsigned long long)num_exp,
(unsigned long long)total_exp);
}
printf("\\n共读取 %llu 次触发，程序退出\\n", (unsigned long long)total_exp);
close(fd);
return 0;
}