【Linux系统编程】（三十五）揭秘 Linux 信号产生：从终端到内核全解析

前言

        在 Linux 系统中，信号是进程间异步通信的 “信使”，而 “信号产生” 则是这个通信过程的起点。无论是我们熟悉的Ctrl+C终止进程，还是程序运行中出现的段错误、定时器超时，本质上都是信号被触发产生的过程。很多开发者只知道 “信号能终止进程”，却不清楚信号到底是怎么来的 —— 是用户操作触发的？还是系统自动产生的？不同场景下信号的产生机制有何不同？

        本文将基于 Linux 内核原理，结合 5 种核心信号产生场景（终端按键、系统命令、函数调用、软件条件、硬件异常），用通俗的语言，带你全方位揭秘信号产生的底层逻辑，让你不仅 “知其然”，更 “知其所以然”。下面就让我们正式开始吧！

一、信号产生的核心本质：谁在 “发送” 信号？

        在深入具体场景之前，我们先明确一个核心问题：信号是由谁产生并发送的？答案是操作系统（OS）。

        无论信号的触发源头是用户按键、函数调用还是硬件异常，最终都必须经过 OS 的 “中转”——OS 会将这些触发事件解释为对应的信号，再发送给目标进程。这是因为 OS 是进程的 “管理者”，只有 OS 拥有操作进程 PCB（进程控制块）的权限，能够修改进程的未决信号集，完成信号的 “投递”。

        举个通俗的例子：信号就像快递，触发信号的源头（用户、函数、硬件）是 “寄件人”，OS 是 “快递员”，目标进程是 “收件人”。寄件人不会直接把快递交给收件人，而是交给快递员，由快递员负责投递到收件人手中，信号的产生与发送也是如此。

        信号产生的完整链路可以总结为：

触发事件（用户/函数/硬件等）→ OS识别事件 → OS将事件映射为对应信号 → OS修改目标进程PCB的未决信号集 → 信号产生并等待递达

        这一链路是所有信号产生场景的共同底层逻辑，接下来我们将针对不同的 “触发事件”，逐一拆解具体场景。

二、场景 1：终端按键触发 —— 最直观的信号产生方式

        终端（Terminal）是用户与 Linux 系统交互的主要界面，我们日常使用的Ctrl+C、Ctrl+\\、Ctrl+Z等组合键，本质上都是通过终端触发信号产生的。这种方式最直观，也是我们接触最多的信号产生场景。

2.1 核心原理：终端按键如何触发信号？

        当我们在终端中按下组合键时，会发生以下一系列动作：

        这里有一个关键规则：终端组合键产生的信号，只能发送给当前前台进程。后台进程（通过&启动的进程）无法接收终端组合键产生的信号，这是为了避免后台进程被用户误操作中断。

2.2 三大常用终端信号：实战验证

        Linux 终端中最常用的三个组合键对应的信号分别是：Ctrl+C（SIGINT）、Ctrl+\\（SIGQUIT）、Ctrl+Z（SIGTSTP），我们通过实战代码逐一验证它们的产生与作用。

2.2.1 Ctrl+C：SIGINT 信号（2 号）—— 终止进程

    SIGINT信号的默认处理动作是 “终止进程”，这是我们最常用的 “强制终止进程” 的方式。

代码验证 1：默认动作 —— 终止进程

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

int main()
{
cout << "进程PID：" << getpid() << "，正在运行…（按下Ctrl+C终止）" << endl;
while (true)
{
sleep(1);
cout << "进程正常运行中…" << endl;
}
return 0;
}

编译运行

g++ sig_int_default.cpp -o sig_int_default
./sig_int_default

        运行后，终端会持续打印 “进程正常运行中…”，此时按下Ctrl+C，进程会立即终止，终端输出如下：

进程PID：12345，正在运行…（按下Ctrl+C终止）
进程正常运行中…
进程正常运行中…
^C # 按下Ctrl+C

代码验证 2：自定义信号处理 —— 让Ctrl+C不终止进程

        我们可以通过signal函数自定义SIGINT信号的处理动作，让按下Ctrl+C后进程不终止，而是执行我们定义的逻辑。

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

// 自定义信号处理函数
void sigint_handler(int signum)
{
cout << "\\n捕获到信号：" << signum << "（SIGINT），Ctrl+C无效！" << endl;
cout << "进程继续运行…" << endl;
}

int main()
{
cout << "进程PID：" << getpid() << "，正在运行…（按下Ctrl+C测试）" << endl;
// 注册SIGINT信号的处理函数
signal(SIGINT, sigint_handler);

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

编译运行

g++ sig_int_catch.cpp -o sig_int_catch
./sig_int_catch

        运行后按下Ctrl+C，进程不会终止，而是打印自定义信息：

进程PID：12346，正在运行…（按下Ctrl+C测试）
进程正常运行中…
进程正常运行中…
^C
捕获到信号：2（SIGINT），Ctrl+C无效！
进程继续运行…
进程正常运行中…

2.2.2 Ctrl+\\：SIGQUIT 信号（3 号）—— 终止进程并生成 Core Dump

    SIGQUIT信号的默认处理动作是 “终止进程并生成 Core Dump 文件”。Core Dump 文件是进程异常终止时的内存镜像文件，包含进程终止时的内存数据、寄存器状态等信息，用于事后调试（Post-mortem Debug）。

核心知识点：Core Dump 文件

• 默认情况下，Linux 系统会禁用 Core Dump 功能（避免泄露敏感信息），可以通过ulimit -c 1024命令临时开启（允许生成最大 1024KB 的 Core 文件）；
• Core 文件的默认名称为core.进程PID，存储在进程运行目录下；
• 可以通过gdb 程序名 core文件名命令调试 Core 文件，定位进程崩溃原因。

代码验证：SIGQUIT 信号的默认动作

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

int main()
{
cout << "进程PID：" << getpid() << "，正在运行…（按下Ctrl+\\\\生成Core文件）" << endl;
while (true)
{
sleep(1);
cout << "进程正常运行中…" << endl;
}
return 0;
}

编译运行与调试

# 开启Core Dump功能（临时生效）
ulimit -c 1024
# 编译
g++ sig_quit_core.cpp -o sig_quit_core
# 运行
./sig_quit_core

        运行后按下Ctrl+\\，进程终止并生成 Core 文件：

进程PID：12347，正在运行…（按下Ctrl+\\生成Core文件）
进程正常运行中…
进程正常运行中…
^\\Quit (core dumped) # 按下Ctrl+\\
# 查看生成的Core文件
ls -l core*

        终端会显示类似core.12347的文件，使用 gdb 调试：

gdb sig_quit_core core.12347

        调试输出会显示进程终止的原因（收到 SIGQUIT 信号），验证了信号的产生与作用。

2.2.3 Ctrl+Z：SIGTSTP 信号（20 号）—— 暂停前台进程

    SIGTSTP信号的默认处理动作是 “暂停前台进程”，将进程从 “运行态” 切换为 “停止态（Stopped）”，并将其转入后台。暂停的进程可以通过fg命令恢复到前台，或通过bg命令让其在后台继续运行。

代码验证：SIGTSTP 信号的默认动作

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

int main()
{
cout << "进程PID：" << getpid() << "，正在运行…（按下Ctrl+Z暂停）" << endl;
while (true)
{
sleep(1);
cout << "进程正常运行中…" << endl;
}
return 0;
}

编译运行与操作

g++ sig_tstp_stop.cpp -o sig_tstp_stop
./sig_tstp_stop

        运行后按下Ctrl+Z，进程被暂停并转入后台：

进程PID：12348，正在运行…（按下Ctrl+Z暂停）
进程正常运行中…
进程正常运行中…
^Z[1]+ Stopped ./sig_tstp_stop # 进程被暂停

        后续操作命令：

# 查看后台暂停的进程
jobs
# 将暂停的进程恢复到前台运行
fg %1
# 将暂停的进程在后台继续运行
bg %1
# 终止后台进程
kill -9 12348

2.3 终端信号的核心总结

        关键规则：终端信号仅发送给前台进程，后台进程（&启动）不受终端组合键影响。

三、场景 2：系统命令触发 —— 通过 Shell 命令发送信号

        除了终端组合键，我们还可以通过 Linux 系统提供的命令主动向进程发送信号，最常用的命令是kill和pkill。这种方式的核心是：通过命令告知 OS “向指定进程发送某个信号”，由 OS 完成信号的产生与投递。

3.1 核心命令：kill 命令的用法

    kill命令的本质是调用系统调用kill()函数，向指定进程发送信号。其基本语法如下：

# 格式1：通过信号名称发送
kill -信号名 进程PID
# 格式2：通过信号编号发送
kill -信号编号 进程PID
# 格式3：列出所有信号
kill -l

        常用信号与 kill 命令组合：

• kill -SIGINT 进程PID：等价于Ctrl+C，终止进程；
• kill -SIGQUIT 进程PID：终止进程并生成 Core Dump；
• kill -SIGKILL 进程PID：强制终止进程（9 号信号，不可捕捉、不可忽略）；
• kill -SIGSTOP 进程PID：暂停进程（19 号信号，不可捕捉、不可忽略）；
• kill -SIGCONT 进程PID：恢复暂停的进程。

3.2 实战验证：用 kill 命令发送信号

步骤 1：编写一个后台运行的死循环程序

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

int main()
{
cout << "后台进程PID：" << getpid() << "，正在运行…" << endl;
while (true)
{
sleep(1);
// 后台运行，不输出过多信息
}
return 0;
}

步骤 2：编译运行并查看进程 PID

# 编译
g++ sig_backend.cpp -o sig_backend
# 后台运行
./sig_backend &
# 查看进程PID（确认进程正在运行）
ps aux | grep sig_backend

        终端输出类似如下（PID 为 12349）：

user 12349 0.0 0.0 4384 820 pts/0 S 10:00 0:00 ./sig_backend

步骤 3：用 kill 命令发送不同信号

验证 1：发送 SIGINT 信号（2 号）

kill -SIGINT 12349
# 或 kill -2 12349

        由于后台进程默认不会处理 SIGINT 信号（除非自定义），进程会继续运行，我们可以通过jobs命令查看：

jobs

        输出显示进程仍在运行：

[1]+ Running ./sig_backend &

验证 2：发送 SIGKILL 信号（9 号）—— 强制终止进程

kill -SIGKILL 12349
# 或 kill -9 12349

        再次查看进程，发现进程已被终止：

ps aux | grep sig_backend
# 无相关进程输出（或显示<defunct>，表示僵尸进程，后续会被系统清理）

验证 3：发送 SIGSEGV 信号（11 号）—— 触发段错误

    SIGSEGV 信号的默认动作是 “终止进程并生成 Core Dump”，通常由非法内存访问触发，但我们也可以通过 kill 命令主动发送：

# 先开启Core Dump功能
ulimit -c 1024
# 重新启动后台进程
./sig_backend &
# 发送SIGSEGV信号
kill -SIGSEGV 12350
# 或 kill -11 12350

        终端输出如下，进程被终止并生成 Core 文件：

[1]+ Segmentation fault (core dumped) ./sig_backend

3.3 扩展命令：pkill 命令 —— 按进程名发送信号

    pkill命令可以根据进程名发送信号，无需手动查询 PID，更方便快捷：

# 终止所有名为sig_backend的进程
pkill -f sig_backend
# 向所有名为sig_backend的进程发送SIGINT信号
pkill -SIGINT -f sig_backend

3.4 系统命令触发信号的核心总结

• 系统命令（kill/pkill）是用户主动发送信号的手段，本质是通过命令调用kill()系统调用；
• 信号的产生仍由 OS 完成，命令仅负责传递 “发送信号” 的请求；
• 9 号信号（SIGKILL）和 19 号信号（SIGSTOP）不可捕捉、不可忽略，是 OS 强制控制进程的终极手段。

四、场景 3：函数调用触发 —— 在代码中主动产生信号

        除了通过终端和命令，我们还可以在 C/C++ 代码中调用特定函数，主动产生信号并发送给进程。Linux 系统提供了三个核心函数：kill()、raise()、abort()，分别用于 “向指定进程发送信号”、“向当前进程发送信号”、“强制当前进程异常终止”。

4.1 kill () 函数：向指定进程发送信号

    kill()函数是kill命令的底层实现，允许进程向另一个进程发送信号，其函数原型如下：

#include <sys/types.h>
#include <signal.h>

int kill(pid_t pid, int sig);

参数说明

• pid：目标进程的 PID，有三种取值：
  • pid > 0：发送信号给 PID 为pid的进程；
  • pid = 0：发送信号给当前进程所在进程组的所有进程；
  • pid = -1：发送信号给当前用户有权限发送的所有进程（除了 init 进程）；
• sig：要发送的信号编号或宏定义（如 SIGINT、SIGKILL）；
• 返回值：成功返回 0，失败返回 – 1，并设置errno。

实战：实现自己的 “kill 命令”

        我们可以用kill()函数实现一个简单的自定义 kill 命令，支持通过 “- 信号编号 进程 PID” 的格式发送信号：

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

int main(int argc, char *argv[])
{
// 检查参数个数：./mykill -signumber pid
if (argc != 3)
{
cerr << "用法错误！正确格式：" << argv[0] << " -signumber pid" << endl;
cerr << "示例：" << argv[0] << " -2 12345（发送SIGINT信号给PID为12345的进程）" << endl;
return 1;
}

// 解析信号编号（去掉argv[1]的 '-' 前缀）
int sig = stoi(argv[1] + 1);
// 解析目标进程PID
pid_t pid = stoi(argv[2]);

// 调用kill()函数发送信号
int ret = kill(pid, sig);
if (ret == 0)
{
cout << "成功向进程PID=" << pid << "发送信号：" << sig << endl;
}
else
{
cerr << "发送信号失败！可能原因：进程不存在、无权限发送信号" << endl;
return 1;
}

return 0;
}

编译运行与测试

# 编译
g++ mykill.cpp -o mykill
# 先启动一个后台进程（如之前的sig_backend）
./sig_backend &
# 用自定义mykill发送SIGINT信号（2号）
./mykill -2 12351
# 用自定义mykill发送SIGKILL信号（9号），强制终止进程
./mykill -9 12351

        终端输出如下，验证了kill()函数的功能：

成功向进程PID=12351发送信号：2
成功向进程PID=12351发送信号：9

4.2 raise () 函数：向当前进程发送信号

    raise()函数用于向当前进程发送信号，等价于kill(getpid(), sig)，函数原型如下：

#include <signal.h>

int raise(int sig);

参数说明

• sig：要发送的信号编号或宏定义；
• 返回值：成功返回 0，失败返回非 0。

实战：每隔 1 秒向自己发送 SIGINT 信号

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

// 自定义信号处理函数
void sig_handler(int signum)
{
cout << "当前进程PID：" << getpid() << "，捕获到信号：" << signum << endl;
}

int main()
{
cout << "进程PID：" << getpid() << "，开始运行…" << endl;
// 注册SIGINT信号的处理函数
signal(SIGINT, sig_handler);

// 每隔1秒，向当前进程发送SIGINT信号
while (true)
{
sleep(1);
// 调用raise()函数发送信号
raise(SIGINT);
}

return 0;
}

编译运行

g++ sig_raise.cpp -o sig_raise
./sig_raise

        终端输出如下，进程每隔 1 秒捕获到一次 SIGINT 信号：

进程PID：12352，开始运行…
当前进程PID：12352，捕获到信号：2
当前进程PID：12352，捕获到信号：2
当前进程PID：12352，捕获到信号：2
…

4.3 abort () 函数：强制当前进程异常终止

    abort()函数用于强制当前进程异常终止，其本质是向当前进程发送SIGABRT信号（6 号），函数原型如下：

#include <stdlib.h>

void abort(void);

核心特点

• abort()函数永远不会返回，调用后进程必然终止；
• 即使进程自定义了SIGABRT信号的处理函数，abort()函数仍会强制终止进程（处理函数会执行，但执行完毕后进程仍会退出）；
• 默认动作是 “终止进程并生成 Core Dump 文件”。

实战：验证 abort () 函数的作用

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

// 自定义SIGABRT信号处理函数
void sigabrt_handler(int signum)
{
cout << "捕获到信号：" << signum << "（SIGABRT），abort()函数被调用！" << endl;
cout << "处理函数执行完毕，进程即将终止…" << endl;
}

int main()
{
cout << "进程PID：" << getpid() << "，开始运行…" << endl;
// 注册SIGABRT信号的处理函数
signal(SIGABRT, sigabrt_handler);

cout << "3秒后调用abort()函数…" << endl;
sleep(3);

// 调用abort()函数，强制终止进程
abort();

// 以下代码永远不会执行
cout << "进程继续运行…" << endl;
return 0;
}

编译运行

g++ sig_abort.cpp -o sig_abort
./sig_abort

        终端输出如下，验证了abort()函数的强制终止特性：

进程PID：12353，开始运行…
3秒后调用abort()函数…
捕获到信号：6（SIGABRT），abort()函数被调用！
处理函数执行完毕，进程即将终止…
Aborted (core dumped)

4.4 函数调用触发信号的核心总结

五、场景 4：软件条件触发 —— 由程序运行状态产生信号

        软件条件触发是指：信号的产生源于程序的运行状态或软件逻辑，而非用户操作或硬件异常。

        最典型的例子是alarm()函数设置的定时器超时（触发SIGALRM信号），以及向已关闭的管道写数据（触发SIGPIPE信号）。

5.1 核心案例 1：alarm () 函数 —— 定时器超时触发 SIGALRM 信号

    alarm()函数用于设置一个定时器，当定时器超时后，OS 会向当前进程发送SIGALRM信号（14 号），其默认处理动作是 “终止进程”。函数原型如下：

#include <unistd.h>

unsigned int alarm(unsigned int seconds);

参数与返回值

• seconds：定时器超时时间（秒），若为 0 则取消之前设置的定时器；
• 返回值：若之前已设置定时器，返回剩余超时时间；若之前无定时器，返回 0。

通俗理解 alarm () 函数

    alarm()函数就像一个 “闹钟”：你设定一个时间（seconds），时间到后闹钟响起（OS 发送 SIGALRM 信号）。如果在闹钟响之前你重新设定了一个新时间，那么旧的闹钟会被取消，返回值是旧闹钟剩余的时间。

实战 1：基本用法 ——1 秒后终止进程

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

int main()
{
cout << "进程PID：" << getpid() << "，设置1秒后触发闹钟…" << endl;
// 设置定时器：1秒后发送SIGALRM信号
alarm(1);

// 死循环，等待信号触发
int count = 0;
while (true)
{
count++;
// 不输出过多信息，避免IO影响计数
}

return 0;
}

编译运行

g++ sig_alarm_basic.cpp -o sig_alarm_basic
./sig_alarm_basic

        1 秒后，进程被 SIGALRM 信号终止，终端输出：

进程PID：12354，设置1秒后触发闹钟…
Alarm clock # SIGALRM信号的默认终止信息

实战 2：捕捉 SIGALRM 信号 —— 统计 1 秒内的循环次数

        我们可以自定义 SIGALRM 信号的处理函数，让定时器超时后不终止进程，而是执行统计逻辑：

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

int count = 0;

// 自定义SIGALRM信号处理函数
void sigalrm_handler(int signum)
{
cout << "1秒时间到！捕获到信号：" << signum << "（SIGALRM）" << endl;
cout << "1秒内循环执行次数：" << count << endl;
// 退出进程
exit(0);
}

int main()
{
cout << "进程PID：" << getpid() << "，设置1秒后触发闹钟…" << endl;
// 注册SIGALRM信号的处理函数
signal(SIGALRM, sigalrm_handler);
// 设置定时器：1秒后发送SIGALRM信号
alarm(1);

// 死循环计数
while (true)
{
count++;
}

return 0;
}

编译运行

g++ sig_alarm_catch.cpp -o sig_alarm_catch
./sig_alarm_catch

        终端输出如下，1 秒后进程打印统计结果并退出：

进程PID：12355，设置1秒后触发闹钟…
1秒时间到！捕获到信号：14（SIGALRM）
1秒内循环执行次数：492333713 # 数值因CPU性能而异

实战 3：重复闹钟 —— 每隔 1 秒触发一次 SIGALRM 信号

    alarm()函数是 “一次性闹钟”，触发后会自动取消。如果想要实现重复触发，可以在信号处理函数中重新调用alarm()：

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

int g_count = 0;

// 自定义SIGALRM信号处理函数
void sigalrm_handler(int signum)
{
g_count++;
cout << "第" << g_count << "次触发闹钟，信号编号：" << signum << endl;
// 重新设置闹钟：1秒后再次触发
alarm(1);
}

int main()
{
cout << "进程PID：" << getpid() << "，设置重复闹钟（每隔1秒触发）…" << endl;
// 注册SIGALRM信号的处理函数
signal(SIGALRM, sigalrm_handler);
// 第一次设置闹钟：1秒后触发
alarm(1);

// 暂停进程，等待信号触发（避免死循环占用CPU）
while (true)
{
pause(); // pause()函数会让进程睡眠，直到收到一个信号
}

return 0;
}

编译运行

g++ sig_alarm_repeat.cpp -o sig_alarm_repeat
./sig_alarm_repeat

        终端输出如下，每隔 1 秒触发一次 SIGALRM 信号：

进程PID：12356，设置重复闹钟（每隔1秒触发）…
第1次触发闹钟，信号编号：14
第2次触发闹钟，信号编号：14
第3次触发闹钟，信号编号：14
…

5.2 核心案例 2：SIGPIPE 信号 —— 向已关闭的管道写数据

    SIGPIPE信号（13 号）的产生条件是：当进程向一个 “读端已关闭” 的管道（pipe）写入数据时，OS 会向该进程发送 SIGPIPE 信号，默认处理动作是 “终止进程”。

管道的核心特性

• 管道是半双工的，分为读端（r）和写端（w）；
• 当所有读端关闭后，写端进程向管道写入数据时，OS 会发送 SIGPIPE 信号终止写端进程；
• 这是为了避免写端进程无意义地写入数据（没有进程读取，数据会丢失）。

实战：触发 SIGPIPE 信号

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

// 自定义SIGPIPE信号处理函数
void sigpipe_handler(int signum)
{
cout << "捕获到信号：" << signum << "（SIGPIPE），向已关闭的管道写数据！" << endl;
exit(1);
}

int main()
{
int pipefd[2]; // pipefd[0]：读端，pipefd[1]：写端
// 创建管道
if (pipe(pipefd) == -1)
{
perror("pipe创建失败");
return 1;
}

cout << "进程PID：" << getpid() << "，管道创建成功（读端：" << pipefd[0] << "，写端：" << pipefd[1] << "）" << endl;

// 注册SIGPIPE信号的处理函数
signal(SIGPIPE, sigpipe_handler);

// 关闭读端（模拟读端已关闭的场景）
close(pipefd[0]);
cout << "已关闭管道读端，尝试向写端写入数据…" << endl;

// 向管道写端写入数据（此时读端已关闭，会触发SIGPIPE信号）
const char *msg = "Hello, Pipe!";
while (true)
{
ssize_t ret = write(pipefd[1], msg, strlen(msg));
if (ret == -1)
{
perror("write失败");
sleep(1);
}
else
{
cout << "成功写入" << ret << "字节数据：" << msg << endl;
}
sleep(1);
}

// 关闭写端（不会执行到这里）
close(pipefd[1]);
return 0;
}

编译运行

g++ sig_pipe.cpp -o sig_pipe
./sig_pipe

        终端输出如下，触发了 SIGPIPE 信号：

进程PID：12357，管道创建成功（读端：3，写端：4）
已关闭管道读端，尝试向写端写入数据…
捕获到信号：13（SIGPIPE），向已关闭的管道写数据！

5.3 软件条件触发信号的核心总结

• 软件条件信号的产生源于程序的运行状态（如定时器超时、管道读写异常）；
• 这类信号是 OS 对程序运行逻辑的 “反馈”，用于告知程序 “某个软件事件已发生”；
• 常见的软件条件信号包括 SIGALRM（定时器超时）、SIGPIPE（管道写失败）、SIGCHLD（子进程终止）等。

六、场景 5：硬件异常触发 —— 由硬件错误产生信号

        硬件异常触发是指：信号的产生源于 CPU 或其他硬件设备的错误，如除零操作、非法内存访问、总线错误等。硬件检测到错误后，会通知 OS，OS 将其映射为对应的信号，发送给当前进程。

        这类信号的本质是：硬件错误通过 OS 转换为软件层面的信号，让进程有机会处理错误（如打印日志、保存数据），若不处理则执行默认动作（通常是终止进程并生成 Core Dump）。

6.1 核心案例 1：除零操作 —— 触发 SIGFPE 信号（8 号）

        当进程执行 “除以零” 的算术运算时，CPU 的运算单元会检测到该错误，通知 OS，OS 将其映射为SIGFPE信号（Floating-point exception，浮点异常），默认处理动作是 “终止进程并生成 Core Dump”。

实战：模拟除零操作触发 SIGFPE 信号

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

// 自定义SIGFPE信号处理函数
void sigfpe_handler(int signum)
{
cout << "捕获到信号：" << signum << "（SIGFPE），发生除零错误！" << endl;
// 退出进程（避免无限循环触发信号）
exit(1);
}

int main()
{
cout << "进程PID：" << getpid() << "，尝试执行除零操作…" << endl;
// 注册SIGFPE信号的处理函数
signal(SIGFPE, sigfpe_handler);

sleep(1); // 延迟1秒，便于观察

// 执行除零操作
int a = 10;
int b = 0;
int c = a / b; // 除零错误，触发SIGFPE信号

// 以下代码不会执行
cout << "计算结果：" << c << endl;
return 0;
}

编译运行

g++ sig_fpe_divzero.cpp -o sig_fpe_divzero
./sig_fpe_divzero

        终端输出如下，触发了 SIGFPE 信号：

进程PID：12358，尝试执行除零操作…
捕获到信号：8（SIGFPE），发生除零错误！

关键注意：为什么会无限触发信号？

        如果我们不在处理函数中退出进程，会发现 SIGFPE 信号会被无限触发。原因是：除零错误发生后，CPU 的状态寄存器会记录该错误状态，若不清理该状态，OS 会持续检测到错误，不断发送 SIGFPE 信号。

        因此，在处理 SIGFPE 信号时，通常需要在处理函数中调用exit()或_exit()终止进程，避免无限循环。

6.2 核心案例 2：非法内存访问 —— 触发 SIGSEGV 信号（11 号）

        当进程访问非法内存地址（如空指针、数组越界）时，MMU（内存管理单元）会检测到该错误，通知 OS，OS 将其映射为SIGSEGV信号（Segmentation fault，段错误），默认处理动作是 “终止进程并生成 Core Dump”。

实战 1：空指针访问触发 SIGSEGV 信号

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

// 自定义SIGSEGV信号处理函数
void sigsegv_handler(int signum)
{
cout << "捕获到信号：" << signum << "（SIGSEGV），非法内存访问！" << endl;
exit(1);
}

int main()
{
cout << "进程PID：" << getpid() << "，尝试访问空指针…" << endl;
// 注册SIGSEGV信号的处理函数
signal(SIGSEGV, sigsegv_handler);

sleep(1);

// 访问空指针（非法内存访问）
int *p = nullptr;
*p = 100; // 触发SIGSEGV信号

// 以下代码不会执行
cout << "赋值成功：" << *p << endl;
return 0;
}

编译运行

g++ sig_segv_nullptr.cpp -o sig_segv_nullptr
./sig_segv_nullptr

        终端输出如下，触发了 SIGSEGV 信号：

进程PID：12359，尝试访问空指针…
捕获到信号：11（SIGSEGV），非法内存访问！

实战 2：数组越界访问触发 SIGSEGV 信号

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

// 自定义SIGSEGV信号处理函数
void sigsegv_handler(int signum)
{
cout << "捕获到信号：" << signum << "（SIGSEGV），数组越界访问！" << endl;
exit(1);
}

int main()
{
cout << "进程PID：" << getpid() << "，尝试数组越界访问…" << endl;
// 注册SIGSEGV信号的处理函数
signal(SIGSEGV, sigsegv_handler);

sleep(1);

// 数组越界访问（非法内存访问）
int arr[5] = {1, 2, 3, 4, 5};
cout << "arr[10] = " << arr[10] << endl; // 触发SIGSEGV信号

return 0;
}

编译运行

g++ sig_segv_array.cpp -o sig_segv_array
./sig_segv_array

        终端输出如下，触发了 SIGSEGV 信号：

进程PID：12360，尝试数组越界访问…
捕获到信号：11（SIGSEGV），数组越界访问！

6.3 核心案例 3：总线错误 —— 触发 SIGBUS 信号（10 号）

    SIGBUS信号（Bus error）的产生条件是：进程访问的内存地址是有效的，但访问方式不正确（如对齐错误、内存映射失败）。与 SIGSEGV 信号（非法地址）的区别在于：SIGBUS 是 “地址有效但访问方式错误”，SIGSEGV 是 “地址本身无效”。

实战：内存对齐错误触发 SIGBUS 信号

        在某些 CPU 架构（如 ARM）中，访问未对齐的内存地址会触发 SIGBUS 信号。以下代码在 x86 架构中可能不会触发，但在 ARM 架构中会触发：

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

// 自定义SIGBUS信号处理函数
void sigbus_handler(int signum)
{
cout << "捕获到信号：" << signum << "（SIGBUS），总线错误（内存对齐错误）！" << endl;
exit(1);
}

int main()
{
cout << "进程PID：" << getpid() << "，尝试访问未对齐的内存地址…" << endl;
// 注册SIGBUS信号的处理函数
signal(SIGBUS, sigbus_handler);

sleep(1);

// 内存对齐错误：char数组的地址是1字节对齐，强制转换为int*（4字节对齐）
char buf[10];
int *p = (int *)(buf + 1); // buf+1的地址不是4的倍数，未对齐
*p = 0x12345678; // 触发SIGBUS信号

// 以下代码不会执行
cout << "赋值成功：" << *p << endl;
return 0;
}

编译运行（ARM 架构）

# 在ARM架构的Linux系统中编译运行
g++ sig_bus_align.cpp -o sig_bus_align
./sig_bus_align

        终端输出如下，触发了 SIGBUS 信号：

进程PID：12361，尝试访问未对齐的内存地址…
捕获到信号：10（SIGBUS），总线错误（内存对齐错误）！

6.4 硬件异常触发信号的核心总结

        关键区别：

• SIGSEGV：地址无效（“地址不存在”）；
• SIGBUS：地址有效，但访问方式错误（“地址存在但进不去”）。

总结

        信号产生是 Linux 信号机制的基础，理解了不同场景下信号的产生逻辑，才能更好地掌握信号的处理与应用。本文的所有代码都经过实战验证，建议大家亲手编译运行，感受信号产生的过程。如果在学习过程中遇到问题，欢迎在评论区留言讨论！