Linux 进程信号:从产生、阻塞到捕捉与子进程回收
当你在终端按下 Ctrl+C,程序为什么会退出?如果程序暂时阻塞了这个信号,之后又会发生什么?本文沿着信号的产生、保存、递达和捕捉,串起 Linux 信号机制,并通过代码观察它的行为。
#mermaid-svg-kc53rKdBgfJv8dHD{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-kc53rKdBgfJv8dHD .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-kc53rKdBgfJv8dHD .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-kc53rKdBgfJv8dHD .error-icon{fill:#552222;}#mermaid-svg-kc53rKdBgfJv8dHD .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-kc53rKdBgfJv8dHD .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-kc53rKdBgfJv8dHD .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-kc53rKdBgfJv8dHD .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-kc53rKdBgfJv8dHD .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-kc53rKdBgfJv8dHD .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-kc53rKdBgfJv8dHD .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-kc53rKdBgfJv8dHD .marker{fill:#333333;stroke:#333333;}#mermaid-svg-kc53rKdBgfJv8dHD .marker.cross{stroke:#333333;}#mermaid-svg-kc53rKdBgfJv8dHD svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-kc53rKdBgfJv8dHD p{margin:0;}#mermaid-svg-kc53rKdBgfJv8dHD .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-kc53rKdBgfJv8dHD .cluster-label text{fill:#333;}#mermaid-svg-kc53rKdBgfJv8dHD .cluster-label span{color:#333;}#mermaid-svg-kc53rKdBgfJv8dHD .cluster-label span p{background-color:transparent;}#mermaid-svg-kc53rKdBgfJv8dHD .label text,#mermaid-svg-kc53rKdBgfJv8dHD span{fill:#333;color:#333;}#mermaid-svg-kc53rKdBgfJv8dHD .node rect,#mermaid-svg-kc53rKdBgfJv8dHD .node circle,#mermaid-svg-kc53rKdBgfJv8dHD .node ellipse,#mermaid-svg-kc53rKdBgfJv8dHD .node polygon,#mermaid-svg-kc53rKdBgfJv8dHD .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-kc53rKdBgfJv8dHD .rough-node .label text,#mermaid-svg-kc53rKdBgfJv8dHD .node .label text,#mermaid-svg-kc53rKdBgfJv8dHD .image-shape .label,#mermaid-svg-kc53rKdBgfJv8dHD .icon-shape .label{text-anchor:middle;}#mermaid-svg-kc53rKdBgfJv8dHD .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-kc53rKdBgfJv8dHD .rough-node .label,#mermaid-svg-kc53rKdBgfJv8dHD .node .label,#mermaid-svg-kc53rKdBgfJv8dHD .image-shape .label,#mermaid-svg-kc53rKdBgfJv8dHD .icon-shape .label{text-align:center;}#mermaid-svg-kc53rKdBgfJv8dHD .node.clickable{cursor:pointer;}#mermaid-svg-kc53rKdBgfJv8dHD .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-kc53rKdBgfJv8dHD .arrowheadPath{fill:#333333;}#mermaid-svg-kc53rKdBgfJv8dHD .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-kc53rKdBgfJv8dHD .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-kc53rKdBgfJv8dHD .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-kc53rKdBgfJv8dHD .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-kc53rKdBgfJv8dHD .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-kc53rKdBgfJv8dHD .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-kc53rKdBgfJv8dHD .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-kc53rKdBgfJv8dHD .cluster text{fill:#333;}#mermaid-svg-kc53rKdBgfJv8dHD .cluster span{color:#333;}#mermaid-svg-kc53rKdBgfJv8dHD 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-kc53rKdBgfJv8dHD .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-kc53rKdBgfJv8dHD rect.text{fill:none;stroke-width:0;}#mermaid-svg-kc53rKdBgfJv8dHD .icon-shape,#mermaid-svg-kc53rKdBgfJv8dHD .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-kc53rKdBgfJv8dHD .icon-shape p,#mermaid-svg-kc53rKdBgfJv8dHD .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-kc53rKdBgfJv8dHD .icon-shape .label rect,#mermaid-svg-kc53rKdBgfJv8dHD .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-kc53rKdBgfJv8dHD .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-kc53rKdBgfJv8dHD .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-kc53rKdBgfJv8dHD :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 是
否
键盘 / 系统调用 / 异常
信号产生
内核记录未决状态
信号被阻塞?
递达
默认动作
忽略
用户态处理函数
这是一幅理解主线的简化图:被忽略的信号可能直接丢弃;进程和线程也有各自相关的信号状态。
一、信号的基本概念
1. 什么是信号?
信号可以理解为:
信号是内核向进程或线程通知事件的一种机制,通常具有异步性。
可以从三个方面理解:
- 通知机制 :告诉进程某个事件发生了,例如用户按下
Ctrl+C。 - 异步性:信号随时可能产生,不需要等待进程执行到某一行代码。
- 由操作系统管理:信号由内核负责记录、发送并安排处理。
信号本身通常不传输大量数据,而是通知进程发生了某个事件。
例如:
./myprocess
# 按下 Ctrl+C
操作系统将终端产生的 SIGINT 信号发送给前台进程组,该信号的默认动作是终止进程。
需要注意,信号的产生并不意味着信号会立即被处理。进程可能先记录信号,稍后再处理。
2. 信号的三种处理方式
| 处理方式 | 含义 | 例子 |
|---|---|---|
默认处理 SIG_DFL |
执行操作系统定义的默认动作 | 终止进程 |
忽略 SIG_IGN |
不执行实际处理动作 | 忽略某个通知 |
| 自定义捕捉 | 调用程序注册的信号处理函数 | 收到 SIGINT 后修改退出标志 |
注意:
- 默认动作不一定是终止进程,也可能是忽略、停止、继续或终止并生成 Core Dump。
SIGKILL(9)和SIGSTOP(19)不能被捕捉、阻塞或忽略。
3. 常见信号及作用
| 信号 | 编号(常见 Linux) | 作用 |
|---|---|---|
SIGHUP |
1 | 终端连接断开等情况 |
SIGINT |
2 | Ctrl+C,中断进程 |
SIGQUIT |
3 | Ctrl+\,终止并可产生 Core Dump |
SIGABRT |
6 | abort() 触发异常终止 |
SIGFPE |
8 | 算术异常,如整数除零 |
SIGKILL |
9 | 强制终止进程 |
SIGSEGV |
11 | 非法内存访问 |
SIGPIPE |
13 | 向没有读端的管道写入数据 |
SIGALRM |
14 | 定时器到期 |
SIGTERM |
15 | 请求进程正常终止 |
SIGCHLD |
17 | 子进程状态发生变化 |
SIGSTOP |
19 | 强制暂停进程 |
SIGCONT |
18 | 恢复暂停的进程 |
这些编号以常见的 Linux x86/x86-64 环境为例,跨平台编程应使用信号宏,而不是直接写数字。
查看全部信号:
kill -l
查看信号手册:
man 7 signal
二、信号产生的四种方式
1. 通过键盘产生信号
终端中的控制组合键可产生信号:
Ctrl+C:产生SIGINT。Ctrl+\:产生SIGQUIT。
执行这些组合键后,终端驱动通知内核,由内核向前台进程组发送相应信号。
2. 通过系统调用或命令发送信号
发送信号既可以在 C 程序中调用函数,也可以在终端执行命令。它们属于不同的使用场景,虽然都能发送信号。
在 C 程序中使用函数
常见接口如下:
c
#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);
int raise(int sig);
kill() 可以向指定进程或进程组发送信号;raise() 向调用它的线程发送信号。下面的程序使用 kill() 向自己发送 SIGTERM:
c
#include <signal.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main(void)
{
pid_t pid = getpid();
printf("向进程 %ld 发送 SIGTERM\n", (long)pid);
fflush(stdout);
if (kill(pid, SIGTERM) == -1) {
perror("kill");
return 1;
}
// SIGTERM 的默认动作是终止进程,通常不会执行到这里。
puts("程序继续运行");
return 0;
}
也可以用 raise() 向调用线程发送同一个信号:
c
#include <signal.h>
int main(void)
{
raise(SIGTERM);
return 0;
}
在终端中使用 kill 命令
假设目标进程的 PID 是 1234:
bash
kill -SIGTERM 1234 # 请求进程终止
kill 1234 # 默认发送 SIGTERM,与上面等价
1234 只是示例,实际使用时应替换为目标进程的 PID。上述命令的发送目标和信号,类似 C 代码中的 kill(1234, SIGTERM)。kill 命令不一定会终止进程:它用于发送信号,效果取决于信号类型和处理方式。
此外,abort() 会使程序因 SIGABRT 异常终止。
3. 由软件条件产生信号
下面是两个常见例子:
SIGPIPE:管道读端全部关闭
当进程继续向没有读端的管道写入时,会触发 SIGPIPE。默认情况下,写入进程终止。
SIGALRM:定时器到期
#include <unistd.h>
unsigned int alarm(unsigned int seconds);
例如:
alarm(5); // 大约5秒后产生SIGALRM
如果没有修改默认处理方式,进程将在收到 SIGALRM 后终止。
alarm() 返回此前定时器剩余的秒数,传入 0 表示取消定时器。
4. 由硬件异常产生信号
某些程序异常由 CPU、MMU 等硬件检测,再由操作系统转换为信号。
| 异常情况 | 对应信号 |
|---|---|
| 整数除零等算术异常 | SIGFPE |
| 访问无效内存地址 | SIGSEGV |
| 执行非法机器指令 | SIGILL |
例如:
int *p = NULL;
*p = 100;
通常会引发 SIGSEGV,默认处理结果是终止进程。
这一节最重要的结论:无论是键盘操作、系统调用、软件条件还是硬件异常,信号最终都由操作系统内核负责发送和管理。
三、信号的未决、阻塞和递达(重点)
这是整个信号章节最重要的原理部分。
1. 三个核心概念
| 概念 | 英文 | 含义 |
|---|---|---|
| 信号未决 | Pending | 信号已经产生,但还没有被处理 |
| 信号阻塞 | Block | 暂时不允许某个信号递达 |
| 信号递达 | Delivery | 实际执行信号处理动作 |
信号处理的基本流程:
信号产生
键盘 / kill / alarm / 硬件异常
内核记录信号
设置 Pending 标志位
检查 Block 标志位
Block = 1
继续保持未决
Block = 0
可以递达
信号递达(Delivery)
执行默认、忽略或自定义动作
例如:
进程正在运行,此时用户按下 Ctrl+C。
如果 SIGINT 没有被阻塞,则它可以递达;如果被阻塞,内核就记录该信号的未决状态,直到阻塞解除后才允许其递达。
2. 信号在内核中如何保存?
内核需要维护信号的状态和处理方式。
为了理解,可以将其看作每个信号对应三种信息:
block:是否阻塞。pending:是否已经产生但尚未递达。handler:信号的处理动作。
| Block | Pending | 含义 |
|---|---|---|
| 0 | 0 | 没有被阻塞,当前没有未决信号 |
| 0 | 1 | 信号已经产生,可以等待内核安排递达 |
| 1 | 0 | 信号被阻塞,但当前没有产生 |
| 1 | 1 | 信号已经产生,因阻塞而保持未决 |
其中:
0表示否。1表示是。
理解重点:
内核管理信号时,既要知道某个信号是否已经到来,又要知道该信号是否允许处理。
因此,Pending 和 Block 必须分别保存。
未阻塞的信号会立即处理吗?
Block = 0、Pending = 1 表示信号已产生且没有被阻塞,具备递达条件;它仍可能等待内核选择合适的时机。没有被阻塞,不等于已经执行了处理动作。
例如,进程 A 向进程 B 发送信号时,A 通过系统调用进入内核,由内核为 B 记录信号。此时 B 可能没有运行,也可能正在另一个 CPU 核心上执行用户态代码,不必同时进入内核态。信号随后可以保持未决,直到内核有机会安排递达。
当 B 的线程执行系统调用、发生异常或受到中断时,CPU 会进入内核态;内核在准备返回用户态时,可以检查待递达信号。实际系统也会通过调度和必要的处理器间通知等机制获得处理机会。具体何时递达没有固定的时间保证。 如果假设目标线程始终没有进入内核,内核也没有其他处理机会,自定义处理函数就不会凭空开始执行。
3. 普通信号与实时信号
信号可以分为普通信号和实时信号。
对于普通信号:
同一种信号在未决期间多次产生,通常只记录一次未决状态。
例如:
- 阻塞
SIGINT。 - 连续按下三次
Ctrl+C。 - 未决信号集中,
SIGINT对应的状态仍然只是1。 - 解除阻塞,通常只会递达一次该信号。
实时信号则支持排队,能够保存同一种信号的多个待处理实例。
4. 阻塞与忽略的区别
这两个概念描述的是不同的事情。
| 对比 | 阻塞 Block | 忽略 Ignore |
|---|---|---|
| 本质 | 不允许信号递达 | 一种信号处理动作 |
| 是否处理信号 | 暂时不处理 | 递达时执行忽略动作 |
| 是否可能保持未决 | 是 | 通常不需要保留 |
| 后续是否可能处理 | 解除阻塞后可以 | 忽略的信号不会执行用户处理动作 |
特别注意:阻塞不等于忽略。
不要依赖被忽略的信号一定会保持未决:内核可能丢弃它。
四、信号集与相关系统调用(重点)
Linux 使用 sigset_t 类型表示信号集。
它可以用于表示阻塞信号集或者未决信号集。
1. 信号集操作函数
#include <signal.h>
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set, int signo);
int sigdelset(sigset_t *set, int signo);
int sigismember(const sigset_t *set, int signo);
| 函数 | 作用 |
|---|---|
sigemptyset |
初始化为空信号集 |
sigfillset |
初始化为包含所有支持信号的集合 |
sigaddset |
向集合添加指定信号 |
sigdelset |
从集合删除指定信号 |
sigismember |
判断指定信号是否在集合中 |
例如:
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGINT);
if (sigismember(&set, SIGINT) == 1) {
printf("SIGINT is in set\n");
}
注意:sigaddset() 只是修改用户提供的信号集,不会直接修改进程的阻塞状态。
2. sigprocmask:修改信号屏蔽字
int sigprocmask(
int how,
const sigset_t *set,
sigset_t *oldset
);
该函数用于读取或者修改调用线程的信号屏蔽字。在多线程程序中,应使用 pthread_sigmask()。
三个重要操作:
| 参数 how | 操作 | 含义 |
|---|---|---|
SIG_BLOCK |
添加阻塞 | 在原有阻塞集合中增加指定信号 |
SIG_UNBLOCK |
解除阻塞 | 从阻塞集合中移除指定信号 |
SIG_SETMASK |
替换阻塞集合 | 将阻塞集合直接替换为 set |
可以将它们理解成以下集合运算:
text
SIG_BLOCK: mask = mask ∪ set
SIG_UNBLOCK: mask = mask − set
SIG_SETMASK: mask = set
例如,阻塞 SIGINT:
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGINT);
sigprocmask(SIG_BLOCK, &set, NULL);
解除阻塞:
sigprocmask(SIG_UNBLOCK, &set, NULL);
3. sigpending:获取未决信号集
int sigpending(sigset_t *set);
作用:读取调用线程可见的未决信号集,包括线程自身及进程共享的未决信号。
例如:
sigset_t pending;
sigpending(&pending);
if (sigismember(&pending, SIGINT) == 1) {
printf("SIGINT is pending\n");
}
注意区分:
sigprocmask():操作阻塞信号集。sigpending():读取未决信号集。sigismember():检查某个信号是否在指定的集合中。
4. 一个完整的实验
下面的程序演示阻塞信号和观察未决状态。
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
int main(void)
{
sigset_t set, pending;
// 1. 创建信号集,加入 SIGINT
sigemptyset(&set);
sigaddset(&set, SIGINT);
// 2. 阻塞 SIGINT
sigprocmask(SIG_BLOCK, &set, NULL);
printf("SIGINT blocked\n");
for (int i = 0; i < 10; ++i)
{
// 3. 获取未决信号集
sigpending(&pending);
printf("SIGINT pending: %d\n",
sigismember(&pending, SIGINT));
sleep(1);
}
// 4. 解除阻塞
sigprocmask(SIG_UNBLOCK, &set, NULL);
printf("SIGINT unblocked\n");
return 0;
}
运行过程中按下 Ctrl+C:
- 在按键之前,输出为
SIGINT pending: 0。 - 按键之后,输出变成
SIGINT pending: 1。 - 解除阻塞后,
SIGINT递达。 - 因为没有设置自定义处理函数,进程会按照默认动作终止,因此通常不会输出最后一行。
通过这个实验,可以把 Pending、Block 和 Delivery 三个概念联系起来。
五、信号捕捉的原理(重点)
1. signal 函数
signal() 可以注册信号处理函数。
#include <signal.h>
void handler(int signo)
{
// 自定义信号处理逻辑
}
int main(void)
{
signal(SIGINT, handler);
while (1) { }
return 0;
}
执行该程序后按下 Ctrl+C,会进入自定义的 handler(),而不是直接按照默认行为退出。
2. 内核如何执行信号处理函数?
用户态程序和内核代码都由 CPU 执行;区别在于 CPU 的特权级和正在执行的代码。线程通过系统调用、中断或异常进入内核,内核在准备返回用户态时可以检查待递达信号。信号产生时目标线程不必正在内核态;信号可以先保持未决。
假设线程正在执行 main(),并且注册了一个会正常返回的处理函数:
用户态 handler 内核态 用户态原程序 用户态 handler 内核态 用户态原程序 #mermaid-svg-Zi5iL1JN7n236CdA{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-Zi5iL1JN7n236CdA .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-Zi5iL1JN7n236CdA .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-Zi5iL1JN7n236CdA .error-icon{fill:#552222;}#mermaid-svg-Zi5iL1JN7n236CdA .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-Zi5iL1JN7n236CdA .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-Zi5iL1JN7n236CdA .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-Zi5iL1JN7n236CdA .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-Zi5iL1JN7n236CdA .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-Zi5iL1JN7n236CdA .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-Zi5iL1JN7n236CdA .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-Zi5iL1JN7n236CdA .marker{fill:#333333;stroke:#333333;}#mermaid-svg-Zi5iL1JN7n236CdA .marker.cross{stroke:#333333;}#mermaid-svg-Zi5iL1JN7n236CdA svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-Zi5iL1JN7n236CdA p{margin:0;}#mermaid-svg-Zi5iL1JN7n236CdA .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-Zi5iL1JN7n236CdA text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-Zi5iL1JN7n236CdA .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-Zi5iL1JN7n236CdA .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-Zi5iL1JN7n236CdA .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-Zi5iL1JN7n236CdA .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-Zi5iL1JN7n236CdA #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-Zi5iL1JN7n236CdA .sequenceNumber{fill:white;}#mermaid-svg-Zi5iL1JN7n236CdA #sequencenumber{fill:#333;}#mermaid-svg-Zi5iL1JN7n236CdA #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-Zi5iL1JN7n236CdA .messageText{fill:#333;stroke:none;}#mermaid-svg-Zi5iL1JN7n236CdA .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-Zi5iL1JN7n236CdA .labelText,#mermaid-svg-Zi5iL1JN7n236CdA .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-Zi5iL1JN7n236CdA .loopText,#mermaid-svg-Zi5iL1JN7n236CdA .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-Zi5iL1JN7n236CdA .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-Zi5iL1JN7n236CdA .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-Zi5iL1JN7n236CdA .noteText,#mermaid-svg-Zi5iL1JN7n236CdA .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-Zi5iL1JN7n236CdA .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-Zi5iL1JN7n236CdA .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-Zi5iL1JN7n236CdA .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-Zi5iL1JN7n236CdA .actorPopupMenu{position:absolute;}#mermaid-svg-Zi5iL1JN7n236CdA .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-Zi5iL1JN7n236CdA .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-Zi5iL1JN7n236CdA .actor-man circle,#mermaid-svg-Zi5iL1JN7n236CdA line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-Zi5iL1JN7n236CdA :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 检查未决且未阻塞的信号保存上下文,安排处理函数 恢复上下文和信号屏蔽字 系统调用、中断或异常返回用户态执行 handler返回后发起 sigreturn返回原执行流程
上图的四次状态切换对应一个典型流程,并非所有信号都必须经历四次切换。sigreturn 是系统调用,不是信号;处理函数没有正常返回时也不会遵循这条完整路径。
具体过程如下:
用户态:执行 main() 函数
程序正常运行
进入内核态
发生中断、异常或系统调用等
内核检查待处理信号
确定需要执行自定义处理函数
返回用户态:执行 handler()
信号捕捉
通过 sigreturn 恢复
由内核恢复原有执行上下文
用户态:继续执行 main()
恢复被中断的执行流程
理解这个过程需要掌握两点:
第一,信号处理函数不是由 main() 主动调用的。
信号捕捉由内核安排执行,因此信号处理函数属于回调函数。
第二,信号处理函数执行结束后,通常会恢复原来的执行流程。
内核需要保存并恢复原来的寄存器状态等上下文信息,才能使程序从被中断的位置继续执行。
再看用户态、内核态和 sigreturn
用户程序和内核代码都由 CPU 执行;用户态和内核态表示 CPU 当前的不同特权级。在用户态,普通程序不能直接访问受保护的内核内存,也不能执行某些特权指令;进入内核态后,CPU 转而执行受控的内核代码。切换状态并不意味着换了一个 CPU。
如果线程一直执行普通用户态指令,且完全没有发生系统调用、中断或异常,它就会一直停留在用户态。实际运行中,中断等事件会让内核获得控制权,因此程序不需要为了处理信号而专门发起系统调用。
sigreturn 不是信号 ,而是用于信号处理返回的系统调用。正常情况下,handler() 在用户态执行完后,系统安排的用户态返回代码发起 sigreturn;CPU 进入内核态,由内核恢复保存的寄存器状态、信号屏蔽字等,然后返回用户态继续原来的流程。这一过程通常自动完成,不需要程序员手动调用。
3. sigaction 函数
实际编程中,通常优先使用行为更明确、功能更完善的 sigaction():
int sigaction(
int signo,
const struct sigaction *act,
struct sigaction *oldact
);
主要结构成员:
| 成员 | 含义 |
|---|---|
sa_handler |
信号处理函数或默认、忽略动作 |
sa_mask |
信号处理期间需要额外阻塞的信号 |
sa_flags |
额外的信号处理选项 |
sa_sigaction |
使用扩展参数的处理函数 |
其中 sa_mask 比较重要;sa_sigaction 要与 SA_SIGINFO 配合使用。
例如,正在执行 SIGINT 的处理函数:
- 内核通常会暂时阻塞当前正在处理的
SIGINT(设置SA_NODEFER等情况除外)。 - 如果希望同时阻塞
SIGQUIT,可以将其加入sa_mask。 - 信号处理函数返回后,内核恢复原来的信号屏蔽字。
因此可以避免同一种信号反复进入处理函数,导致执行流程混乱。
六、可重入函数、volatile 与竞态条件
1. 什么是可重入函数?
以链表插入操作为例。
假设:
main()正在调用insert(),修改全局链表。- 插入操作执行到一半时,进程捕捉到一个信号。
- 信号处理函数也调用
insert()修改同一条链表。 - 信号处理结束后,原来的
insert()继续执行。 - 两次插入操作可能互相干扰,导致链表结构错误。
因为 insert() 在第一次调用尚未结束时再次被调用,而且共享可变数据,可能产生错误,因此它不是可重入函数。
可重入函数:即使在上一次调用尚未结束时再次进入,也不会破坏执行结果和共享状态的函数。
在信号处理函数中,要特别避免调用非异步信号安全函数。
例如,printf()、malloc() 等一般不适合直接放在信号处理函数中使用。
2. volatile 关键字
可以用一个标志变量说明 volatile 的作用。
例如:
int flag = 0;
void handler(int sig)
{
flag = 1;
}
int main(void)
{
signal(SIGINT, handler);
while (!flag) { }
return 0;
}
在优化编译时,编译器可能认为 flag 不会在循环中变化,把读取操作优化掉,造成进程一直循环。
对于信号处理中的简单标志,还需要选择合适的数据类型。
更规范的信号处理示例是:
#include <signal.h>
volatile sig_atomic_t flag = 0;
void handler(int sig)
{
flag = 1;
}
int main(void)
{
signal(SIGINT, handler);
while (!flag) { }
return 0;
}
这里使用 sig_atomic_t,是为了让信号处理函数与主执行流程之间的简单标志访问符合 C 语言的相关要求。
注意:volatile 不是线程同步机制,也不能保证复合操作的原子性。
3. 竞态条件
竞态条件是指:程序执行结果受到多个事件发生先后顺序的影响。
例如:
if (flag == 0) {
pause();
}
如果信号恰好在检查 flag 后、执行 pause() 前发生,信号处理函数可能已经执行完成。之后程序才进入 pause(),就可能一直等待新的信号。
这就是信号处理中典型的竞态条件。
在需要原子地解除屏蔽并等待信号时,可以使用 sigsuspend()。
七、SIGCHLD 信号与子进程回收
子进程状态变化也可以通过信号通知父进程。
1. 为什么需要 SIGCHLD?
之前学习 wait() 和 waitpid() 时,父进程需要主动回收子进程。
常见方法有两种:
- 阻塞等待:父进程使用
wait(),但等待期间不能继续执行其他工作。 - 非阻塞轮询:父进程使用
waitpid(..., WNOHANG),需要反复检查。
现在可以利用 SIGCHLD:
子进程退出时,内核向父进程发送 SIGCHLD,父进程捕捉信号后回收子进程。
这样父进程不需要一直等待或者反复轮询。
2. 使用 SIGCHLD 回收子进程
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>
#include <errno.h>
void handler(int sig)
{
int saved_errno = errno;
(void)sig;
while (waitpid(-1, NULL, WNOHANG) > 0)
{
// 回收已经退出的子进程
}
errno = saved_errno;
}
int main(void)
{
struct sigaction sa = {0};
sa.sa_handler = handler;
sigemptyset(&sa.sa_mask);
sigaction(SIGCHLD, &sa, NULL);
pid_t pid = fork();
if (pid == 0)
{
sleep(3);
exit(0);
}
while (1)
{
printf("father working...\n");
sleep(1);
}
return 0;
}
这里最关键的是:
while (waitpid(-1, NULL, WNOHANG) > 0)
为什么使用 while 而不是 if?
因为多个子进程可能几乎同时退出,而普通的 SIGCHLD 信号不会对每次退出都保留一个独立的待处理实例。
所以,一个 SIGCHLD 信号处理过程可能需要回收多个子进程。
另一种方式是:在 Linux 下,将 SIGCHLD 显式设置为 SIG_IGN,可以让已退出的子进程自动回收。需要注意,默认忽略 SIGCHLD 与显式设置 SIG_IGN 并不完全等价。
八、Core Dump:核心转储
某些信号的默认动作还包括生成核心转储。
Core Dump(核心转储)是程序状态的快照,通常在进程因某些信号异常终止时由系统生成,可用于事后调试。它可以包含部分内存、寄存器和线程状态等信息;开发者可以结合可执行文件,用 gdb 查看调用栈和变量。是否实际生成、生成到哪里,取决于资源限制和系统配置。
例如程序发生非法内存访问,产生 SIGSEGV,默认处理通常会终止进程并可生成 Core Dump。
常见命令:
ulimit -c # 查看核心转储文件大小限制
ulimit -c unlimited # 允许生成核心转储
在系统配置允许的情况下,可以用 gdb 分析:
gdb ./myprogram core
不过现代 Linux 也可能将核心转储交给 systemd-coredump 等服务管理,不一定直接在当前目录产生 core 文件。
九、常见问题小结
| 问题 | 回答 |
|---|---|
| 信号产生后一定立即处理吗? | 不一定;它可能先保持未决,递达时间没有固定保证。 |
| 阻塞和忽略一样吗? | 不一样;阻塞控制递达,忽略是信号的处理方式。 |
| 普通信号产生多次就一定处理多次吗? | 不一定;同一种普通信号的多个未决实例可能合并。 |
SIGKILL 和 SIGSTOP 能捕捉吗? |
不能捕捉、阻塞或忽略。 |
kill() 只能终止进程吗? |
不是,它用于发送指定信号。 |
sigreturn 是一种信号吗? |
不是,它是用于恢复信号处理前状态的系统调用。 |
信号机制的主线是:事件产生信号,内核管理未决状态和屏蔽状态,在适当时机递达,并依据处理方式执行默认动作、忽略或安排用户态处理函数。