建议收藏！信号和信号量，你真的会了吗？一、信号（Signal） 1. 什么是信号？信号（Signal）是 Linux

一句话区别：

信号（Signal）：通知进程"发生了一件事"（异步通知机制）。

信号量（Semaphore）：控制多个线程/进程"谁可以使用资源"（同步互斥机制）。

一、信号（Signal）

1. 什么是信号？

信号（Signal）是 Linux 内核向进程发送的一种异步通知机制。

它用于通知进程：

用户按下 Ctrl+C
子进程退出
定时器超时
非法访问内存
管道断开

可以理解为：

信号 = 中断 + 通知

例如：

Ctrl + C
    │
    ▼
Linux Kernel
    │
发送 SIGINT
    │
    ▼
进程收到信号

Kernel（内核）是计算机操作系统最核心的程序，主要负责管理硬件资源、充当软件与硬件的桥梁以及控制系统安全。

2. 信号的特点

异步发生
不携带大量数据（普通信号只有编号）
可以打断程序当前执行流程
每个信号都有编号
大多数信号可以被捕获（signal/sigaction）

3. 常见信号

信号	编号	含义
SIGHUP	1	终端断开
SIGINT	2	Ctrl+C
SIGQUIT	3	Ctrl+\
SIGILL	4	非法指令
SIGABRT	6	abort()：非正常退出
SIGFPE	8	除零异常
SIGKILL	9	强制结束（不能捕获）
SIGSEGV	11	段错误
SIGPIPE	13	管道断开
SIGALRM	14	alarm() 定时器
SIGTERM	15	正常结束
SIGCHLD	17	子进程结束
SIGCONT	18	继续运行
SIGSTOP	19	暂停（不能捕获）
SIGTSTP	20	Ctrl+Z

查看：

kill -l

flowchart TD
    A[程序运行] --> B{收到什么信号?}

    B -->|Ctrl+C| C[SIGINT<br/>退出]
    B -->|Ctrl+\\| D[SIGQUIT<br/>退出+Core]
    B -->|Ctrl+Z| E[SIGTSTP<br/>暂停]
    B -->|kill| F[SIGTERM<br/>正常退出]
    B -->|kill -9| G[SIGKILL<br/>强制退出]
    B -->|kill -STOP| H[SIGSTOP<br/>强制暂停]
    H -->|kill -CONT| I[SIGCONT<br/>继续]
    E -->|fg/bg| I

    B -->|除0| J[SIGFPE]
    B -->|非法内存| K[SIGSEGV]
    B -->|非法指令| L[SIGILL]
    B -->|abort| M[SIGABRT]
    B -->|alarm到时| N[SIGALRM]
    B -->|终端关闭| O[SIGHUP]
    B -->|子进程结束| P[SIGCHLD]
    B -->|写入断开的管道/Socket| Q[SIGPIPE]

4. 信号产生方式

（1）键盘产生

例如：

Ctrl+C

发送：

SIGINT

用户
 │
 │ Ctrl+C
 ▼
终端
 │
 ▼
Kernel
 │
 ▼
进程

（2）kill命令

例如：

kill -15 pid

或者

kill -9 pid

（3）系统调用

例如：

kill(pid,SIGUSR1);

或者

raise(SIGINT);

当前进程主动给自己发送一个 SIGINT 信号。

（4）硬件异常

例如：

int a=1/0;

产生：

SIGFPE

访问非法地址：

SIGSEGV

（5）软件条件

例如：

alarm(5);

五秒后：

SIGALRM

5. 信号处理方式

收到信号以后，有三种处理方式：

graph TD
    A[收到信号] --> B{查询信号处理动作}
    B -->|SIG_DFL| C[默认处理<br/>Default]
    B -->|SIG_IGN| D[忽略<br/>Ignore]
    B -->|User Handler| E[用户捕获<br/>Catch]

默认处理

例如：

SIGTERM

默认：

退出程序

忽略

例如：

signal(SIGINT,SIG_IGN);

按 Ctrl+C：

没有反应

捕获

例如：

void handler(int sig)
{
    printf("收到信号%d\n",sig);
}

signal(SIGINT,handler);

收到：

SIGINT

执行：

handler()

6. signal()

#include <signal.h>

signal(SIGINT,handler);

作用：

安装一个信号处理函数。

流程：

flowchart TD
    A[收到 SIGINT] --> B[Kernel: 检查处理动作]
    B --> C{是否为自定义 handler?}
    C -- 是 --> D[Kernel: 保存用户态上下文]
    D --> E[Kernel: 切换到信号栈]
    E --> F[执行 handler]
    F --> G[执行 sigreturn 系统调用]
    G --> H[Kernel: 恢复用户态上下文]
    H --> I[返回程序继续执行]
    C -- 否 --> J[执行默认动作/忽略]

7. sigaction()

推荐使用。

比 signal() 更安全。

struct sigaction act;

act.sa_handler=handler;

sigaction(SIGINT,&act,NULL);

优势：

更稳定
可以设置屏蔽信号
可以设置更多属性

8. 信号屏蔽

有时候：

不希望现在处理信号。

可以：

先屏蔽
以后再处理

流程：

flowchart LR
A[收到 SIGINT]
B[加入Pending]
C[解除屏蔽]
D[执行handler]

A --> B --> C --> D

常见函数：

sigprocmask()

**<font style="color:rgb(34, 34, 34);">sigprocmask</font>** 是用于检查或修改当前线程信号屏蔽字（Signal Mask）的系统调用，其核心作用是控制哪些信号在当前时刻被“阻塞”（即暂时不递送给进程），从而实现对信号处理的精确时序控制。

9. 未决信号（Pending）

收到信号：

并不会马上执行

可能：

Pending

等待解除屏蔽。

流程：

产生信号
    │
    ▼
Pending
    │
解除Mask
    ▼
执行Handler

10. 信号生命周期

flowchart LR
A[产生 Signal]
B[Pending]
C[是否屏蔽?]

A --> B
B --> C
C -- 是 --> B
C -- 否 --> D[Delivery]
D --> E[Handler]

二、信号量（Semaphore）

1. 什么是信号量？

信号量（Semaphore）用于：

同步多个线程/进程对共享资源的访问。

它本质上就是：

一个整数

谁拿到资源：

--

释放资源：

++

2. 为什么需要信号量？

例如：

厕所只有3个坑位。

来了10个人。

坑位：3

A ✔
B ✔
C ✔

D 等待
E 等待
...

只有出来一个：

++

等待的人：

--

进入。

3. 信号量分类

二值信号量

只有：

0
1

作用：

类似：

Mutex

计数信号量

例如：

表示：

有5个资源

4. P操作和 V操作

经典名称：

P()

申请资源。

sem_wait()

value--

如果：

value<0

阻塞。

V()

释放资源。

sem_post()

value++

唤醒等待线程。

图解

假设：

Semaphore=3

sequenceDiagram
    participant S as Semaphore (初始值=2)
    participant A as 线程A
    participant B as 线程B
    participant C as 线程C
    participant D as 线程D

    Note over S: 初始值 = 2

    A->>S: P()
    S-->>S: 值: 2 → 1
    Note right of A: ✅ 获取成功，继续执行

    B->>S: P()
    S-->>S: 值: 1 → 0
    Note right of B: ✅ 获取成功，继续执行

    C->>S: P()
    S-->>S: 值: 0 → -1
    Note right of C: ⏳ 信号量 < 0，进入等待队列

    D->>S: P()
    S-->>S: 值: -1 → -2
    Note right of D: ⏳ 信号量 < 0，进入等待队列

    Note over S: 当前状态：2个线程运行，2个线程等待

线程A：

V()

Semaphore=0

↓

线程D 被唤醒

5. Linux POSIX信号量

头文件：

#include <semaphore.h>

创建：

sem_t sem;

初始化：

sem_init(&sem,0,3);

表示：

三个资源

等待：

sem_wait(&sem);

相当于：

P()

释放：

sem_post(&sem);