【无标题】

刚学操作系统那会儿，真的很懵圈！信号量机制咋既在进程同步互斥里当"C位主角"，又在进程通信里跑龙套？翻遍网上面试题和博客，全是"进程通信机制有哪些？"的复读机，进程同步互斥反而被冷落得像空气......那时候真的希望：能有一篇讲透信号量的博客摆在我面前！ 😂

希望这篇文章能够拯救某段时间和我一样被绕晕的小伙伴~

一、什么是进程通信

1.1 进程通信的定义与本质

在操作系统的世界里，进程是资源分配和调度的基本单位 。每个进程都拥有独立的用户地址空间，就像一个个独立的小王国，彼此不能直接访问对方的数据。但在实际的系统运行中，进程之间又需要相互协作，共同完成复杂的任务，这就引出了进程通信（Inter - Process Communication，IPC）的概念。进程通信，简单来说，就是操作系统中多个独立进程之间实现数据交换与信息传递的机制。

由于进程地址空间的隔离，进程间通信需要借助一些特殊的手段。通常，这些手段是由操作系统内核提供的，比如在内核空间开辟缓冲区，或者利用内核提供的中间件来完成数据的交互。所以，进程通信的本质，就是突破进程地址空间的隔离限制，通过内核提供的服务，实现多个进程之间的协作，让它们能够共享信息、协同工作，就像不同的小王国之间建立起了沟通的桥梁。

1.2 进程通信的核心目的

进程通信有着明确而重要的目标，主要体现在以下三个方面：

• 数据传输：实现进程间批量数据的交换。比如在一个多媒体处理系统中，视频解码进程需要将解码后的视频帧数据传递给视频渲染进程，以便在屏幕上显示出画面。这就需要通过进程通信机制，高效、准确地将大量的视频数据从一个进程传输到另一个进程。
• 资源共享与同步：协调多个进程对共享资源的访问顺序，避免竞态条件。当多个进程同时访问共享资源（如共享内存、文件等）时，如果没有合适的同步机制，就可能导致数据不一致或程序错误。通过进程通信，可以传递同步信号，让进程按照正确的顺序访问共享资源，保证系统的稳定性和正确性 。例如，多个进程同时对一个共享文件进行读写操作，利用进程通信的同步机制，可以确保每个进程在合适的时机进行操作，避免文件内容被破坏。
• 事件通知：让进程感知并响应系统或其他进程触发的异步事件。在系统运行过程中，会发生各种异步事件，如用户输入、硬件中断等。进程通信可以将这些事件的发生通知到相关进程，使它们能够及时做出反应。比如，当用户按下键盘上的某个按键时，系统会产生一个中断事件，通过进程通信，将这个事件通知给处理用户输入的进程，该进程就可以根据按键信息进行相应的处理 。

二、管道

在进程通信的工具库中，管道是一种古老而基础的通信方式，它就像一根连接不同进程的水管，在进程间传递数据。

2.1 管道的核心工作原理

管道是操作系统内核在内存中开辟的临时缓冲区，本质上是一种单向数据流通道，通过文件描述符来实现读写操作。它就像一个单行道，数据只能朝着一个方向流动。在实际操作中，一个进程负责往管道的写端写入数据，这些数据就像水流一样流入管道的缓冲区；另一个进程则从管道的读端读取数据，将缓冲区中的数据 "取走" 。整个过程遵循先进先出（FIFO，First - In - First - Out）的原则，就像我们日常生活中排队一样，先进入管道的数据会被先读取出来，不存在插队的情况。比如，在 Linux 系统中，我们在命令行输入 "ls -l | grep test"，这里的 "|" 就是管道符号，"ls -l" 命令的输出结果作为数据，通过管道传递给 "grep test" 命令作为输入，实现了两个命令（进程）之间的数据交互。

2.2 匿名管道（无名管道）

匿名管道是最基础的管道类型，在 C 语言中，通过pipe函数创建。

它就像一个临时搭建的简易通道，仅支持具有亲缘关系的进程之间通信，比如父子进程或者兄弟进程 。这是因为匿名管道没有名字，它依赖于进程间共享的文件描述符来实现数据传递。当一个进程创建了匿名管道后，它的子进程可以通过继承父进程的文件描述符来访问这个管道，从而实现父子进程间的数据通信。而且匿名管道的生命周期与创建它的进程紧密绑定，一旦创建管道的进程终止，这个匿名管道也会随之自动销毁，就像临时搭建的通道在使用完后被拆除一样。

下面是一段使用匿名管道实现父子进程通信的简单 C 代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>


int main() {
    int fd[2];
    // 创建匿名管道，fd[0]为读端，fd[1]为写端
    if (pipe(fd) == -1) {
        perror("pipe");
        return 1;
    }


    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    } else if (pid == 0) {  // 子进程
        close(fd[0]);  // 子进程关闭读端
        char *msg = "Hello from child";
        // 子进程向管道写端写入数据
        if (write(fd[1], msg, strlen(msg)) == -1) {
            perror("write");
            return 1;
        }
        close(fd[1]);  // 关闭写端
    } else {  // 父进程
        close(fd[1]);  // 父进程关闭写端
        char buf[100];
        // 父进程从管道读端读取数据
        ssize_t n = read(fd[0], buf, sizeof(buf) - 1);
        if (n == -1) {
            perror("read");
            return 1;
        }
        buf[n] = '\0';  // 添加字符串结束符
        printf("Received from child: %s\n", buf);
        close(fd[0]);  // 关闭读端
    }


    return 0;
}

在这个示例中，父进程创建了匿名管道和子进程，子进程向管道写端写入数据，父进程从读端读取数据，完成了父子进程间的简单通信。

2.3 命名管道（FIFO）

命名管道突破了匿名管道只能用于亲缘关系进程通信的限制，通过mkfifo函数创建。它以特殊文件的形式存在于文件系统中，就像在文件系统中创建了一个特殊的 "邮箱"，即使是没有亲缘关系的进程，只要知道这个 "邮箱" 的路径，就可以通过访问这个文件路径来实现数据交互 。例如，进程 A 和进程 B 是两个完全独立的进程，它们可以通过共同访问同一个命名管道文件来进行通信，进程 A 往命名管道中写入数据，进程 B 从命名管道中读取数据。而且命名管道的生命周期独立于进程，它不会因为某个进程的结束而消失，就像一个固定的邮箱不会因为某个人的离开而消失一样，只有当我们手动删除这个命名管道文件时，它所占用的资源才会被释放。下面是一个使用命名管道实现两个无亲缘关系进程通信的示例： 假设有两个文件，write_fifo.c和read_fifo.c。

write_fifo.c：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>


#define FIFO_PATH "./myfifo"


int main() {
    int fd;
    char message[100];
    int count = 1;
    // 尝试创建FIFO，如果已存在则忽略错误
    if (mkfifo(FIFO_PATH, 0664) == -1 && errno != EEXIST) {
        perror("mkfifo");
        return 1;
    }
    printf("Writer: Waiting to open FIFO for writing...\n");
    // 以只写方式打开FIFO，如果此时没有读者打开，这里会阻塞
    fd = open(FIFO_PATH, O_WRONLY);
    if (fd == -1) {
        perror("open fifo error");
        return 1;
    }
    printf("Writer: FIFO opened. Start writing.\n");
    while (1) {
        // 格式化消息内容
        snprintf(message, sizeof(message), "Message #%d from writer", count++);
        // 向FIFO写入数据
        if (write(fd, message, strlen(message)) == -1) {
            perror("write");
            break;
        }
        printf("Sent: '%s'\n", message);
        sleep(1);  // 每秒发送一次
    }
    close(fd);
    return 0;
}

read_fifo.c：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


#define FIFO_PATH "./myfifo"


int main() {
    int fd;
    char buffer[100];
    int n;
    printf("Reader: Waiting to open FIFO for reading...\n");
    // 以只读方式打开FIFO
    fd = open(FIFO_PATH, O_RDONLY);
    if (fd == -1) {
        perror("open fifo error");
        return 1;
    }
    printf("Reader: FIFO opened. Waiting for data...\n");
    while ((n = read(fd, buffer, sizeof(buffer))) > 0) {
        buffer[n] = '\0';
        printf("Received: '%s'\n", buffer);
    }
    if (n == 0) {
        printf("Reader: All writers have closed the FIFO. Exiting.\n");
    }
    close(fd);
    return 0;
}

write_fifo.c进程负责向命名管道中写入数据，read_fifo.c进程负责从命名管道中读取数据，实现了两个无亲缘关系进程之间的通信。

往期精选干货 | C/C++ 开发进阶攻略

👉 搞懂 C++ 就业前景 & 求职避坑：为什么很多人劝退学 C++，但大厂核心岗位还是要 C++？

👉 大厂后端岗系统进阶路线：【大厂标准】Linux C/C++ 后端进阶学习路线

👉 音视频赛道核心学习路径：音视频流媒体高级开发 - 学习路线

👉 Qt 桌面 / 嵌入式开发全闭环攻略：C++ Qt 学习路线一条龙！（桌面开发 & 嵌入式开发）

👉 Linux 内核硬核修炼指南：Linux 内核学习指南，硬核修炼手册

👉 面试冲刺高频八股题库：C/C++ 高频八股文面试题 1000 题（三）
👉 C++ 实操能力硬核提升：手撕线程池：C++ 程序员的能力试金石

三、消息队列

消息队列是进程通信中一种独特且灵活的方式，它为进程间的异步通信提供了有力支持。

3.1 消息队列的定义与结构

消息队列是内核维护的一种以 "消息" 为基本单位的进程通信机制 。它就像一个存放消息的大仓库，每个消息都带有一个自定义的类型标识，就像给每个货物贴上了不同类型的标签。这使得进程在读取消息时，可以按照消息类型进行筛选，而不是像管道那样只能按照先进先出的顺序读取。比如在一个分布式系统中，可能同时存在订单消息、用户登录消息、系统通知消息等不同类型的消息，各个进程可以根据自己的需求，从消息队列中读取特定类型的消息进行处理 。从结构上看，消息队列通常由消息头和消息体组成，消息头包含了消息的类型、长度等元信息，消息体则存储了实际的消息内容。在 Linux 系统中，通过msgget函数来创建或获取一个消息队列的标识符，就像获取仓库的钥匙一样，后续对消息队列的操作都基于这个标识符进行。

3.2 消息队列的核心通信机制

消息队列基于msgsnd（发送）和msgrcv（接收）两个原语实现进程间的通信 。从通信方式上，主要分为直接消息传递和信箱消息传递两种方式。直接消息传递就像两个人直接面对面交流，没有中间的缓冲环节，要求发送进程和接收进程必须同时处于运行状态，即同步执行，就像两个人必须同时在场才能交流一样，一方离开就无法完成通信。而信箱消息传递则引入了信箱（消息队列）这个中间缓冲，发送进程把消息放入信箱，接收进程可以在合适的时候从信箱中读取消息，两者无需实时等待对方，实现了异步工作 。例如在一个电商系统中，订单生成进程（发送者）将订单消息发送到消息队列（信箱），库存更新进程（接收者）可以在空闲时从消息队列中读取订单消息，进行库存更新操作，订单生成进程无需等待库存更新进程处理完订单消息，大大提高了系统的并发处理能力。

3.3 消息队列的优势与局限

消息队列在进程通信中具有显著的优势 。首先，它实现了发送进程和接收进程的解耦，两者无需直接关联，就像寄信人和收信人不需要直接联系，只通过信箱（消息队列）来传递信息 。其次，支持异步通信，发送进程可以在发送消息后继续执行其他任务，无需等待接收进程的处理结果，提高了系统的整体效率。此外，消息队列还能缓存消息，在接收进程繁忙或暂时不可用时，消息不会丢失，就像信箱可以暂时存放信件一样 。但是，消息队列也存在一些局限性。在数据传输过程中，消息需要经过 "用户态 - 内核态" 两次拷贝，这增加了数据传输的开销，如果频繁进行消息通信，会对系统性能产生一定影响。而且，消息队列资源不会自动销毁，一旦创建，如果在程序结束时没有手动释放，就会导致内存泄漏，占用系统资源 。例如在一个长时间运行的服务器程序中，如果不断创建消息队列却不释放，随着时间的推移，系统资源会被逐渐耗尽，最终导致服务器性能下降甚至崩溃。

四、共享内存

共享内存是一种高效的进程通信机制，在大数据量、高性能要求的场景中发挥着关键作用。

4.1 共享内存的核心原理与核心优势

共享内存是效率最高的 IPC 机制，其核心原理是操作系统在物理内存中开辟一块共享内存段，然后让多个进程将该内存段映射到自身的虚拟地址空间 。这就好比多个房间（进程）都安装了通往同一个仓库（共享内存）的门，每个房间的人都可以直接进入仓库拿取或存放物品，而无需在房间之间搬运物品。进程可直接读写该区域数据，无需进行数据拷贝，这大大降低了 CPU 和 IO 的消耗，提高了数据传输的效率 。例如，在一个视频编辑软件中，视频解码进程和视频特效处理进程可以通过共享内存直接共享解码后的视频帧数据，特效处理进程无需等待数据的复制过程，就能立即对视频帧进行特效处理，大大提高了视频编辑的效率。

4.2 System V 共享内存的实现步骤

在 Linux 系统中，System V 共享内存的实现通常分为以下四个关键步骤 ：

1. 生成键值：通过ftok函数生成一个唯一的key值，这个key值就像共享内存段的 "身份证"，用于标识共享内存段 。ftok函数需要一个文件路径和一个项目 ID 作为参数，它会根据这两个参数生成一个唯一的key值。例如，key_t key = ftok("/tmp/shmfile", 1);，这里以/tmp/shmfile文件和项目 ID 为 1 生成key值。
2. 创建或获取共享内存段：利用shmget函数创建新的共享内存段，或者获取已存在的共享内存段 。如果是创建新的共享内存段，需要指定共享内存的大小、访问权限等参数。例如，int shmid = shmget(key, 1024, IPC_CREAT | 0666);，这里创建了一个大小为 1024 字节，权限为可读可写的共享内存段，shmid为返回的共享内存段标识符。
3. 映射内存段：通过shmat函数将共享内存段映射到进程的地址空间，这样进程就可以像访问自己的内存一样访问共享内存 。例如，char *shmaddr = (char *)shmat(shmid, NULL, 0);，将共享内存段映射到当前进程的地址空间，shmaddr为映射后的地址。
4. 解除映射与删除：使用完共享内存后，通过shmdt函数解除共享内存段与进程地址空间的映射 。当不再需要共享内存段时，调用shmctl函数并传入IPC_RMID命令来完成内存段的删除 。例如，shmdt(shmaddr);解除映射，shmctl(shmid, IPC_RMID, NULL);删除共享内存段。

4.3 共享内存的注意事项

在使用共享内存时，有一些重要的注意事项需要牢记 ：

• 同步问题：共享内存本身没有内置的同步互斥机制，当多个进程同时对共享内存进行读写操作时，很容易引发数据竞争问题，导致数据不一致或程序出错 。因此，在使用共享内存时，通常需要结合信号量、互斥锁等同步机制来保证数据的一致性和操作的原子性。例如，在一个多进程的数据库缓存系统中，如果多个进程同时对共享内存中的缓存数据进行读写操作，没有同步机制的保护，就可能导致缓存数据的混乱，影响数据库的正常运行。
• 内存泄漏风险：共享内存段不会随着进程的终止而自动销毁，如果在程序结束时没有手动调用shmctl（System V 共享内存）或shm_unlink（POSIX 共享内存）命令进行回收，就会造成系统内存泄漏，浪费宝贵的内存资源 。比如，在一个长时间运行的服务器程序中，如果频繁创建共享内存段却不释放，随着时间的推移，系统内存会被逐渐耗尽，最终导致服务器性能下降甚至崩溃。所以，在程序中一定要养成及时释放共享内存资源的好习惯，确保系统的稳定运行。

五、信号量和 PV 操作

信号量和 PV 操作是操作系统中用于实现进程同步和互斥的重要机制，它们在协调多个进程对共享资源的访问方面发挥着关键作用。

5.1 信号量的定义与类型

信号量是由内核保护的整数计数器，用于协调多个进程对共享资源的访问 。它就像一个资源管理员，时刻记录着可用资源的数量。根据其取值范围和功能，信号量主要分为以下两种类型：

• 二元信号量：二元信号量的初始值为 1，它主要用于实现对共享资源的互斥访问 。在任何时刻，最多只有一个进程能够获取到二元信号量，就像一把锁，同一时间只能被一个人持有。当一个进程获取到二元信号量后，其他进程如果试图获取，就必须等待，直到持有信号量的进程释放它。例如，在一个多进程的文件读写系统中，为了保证同一时刻只有一个进程能够对文件进行写入操作，避免数据冲突，可以使用二元信号量来实现互斥访问 。
• 计数信号量：计数信号量的初始值为 N（N 为大于 0 的整数），它表示当前可用的资源数量 。当一个进程需要使用资源时，它会尝试获取计数信号量，如果信号量的值大于 0，说明有可用资源，进程可以获取信号量并使用资源，同时信号量的值减 1；如果信号量的值为 0，说明资源已被全部占用，进程需要等待 。例如，在一个数据库连接池的管理中，假设有 10 个数据库连接可供使用，那么可以使用计数信号量来管理这些连接，初始值设为 10。每个需要使用数据库连接的进程在获取连接前，先获取计数信号量，获取成功后就可以使用一个连接，使用完后释放信号量，这样就可以确保不会有超过 10 个进程同时获取连接，避免了资源的过度使用。

5.2 PV 操作的核心原理

PV 操作是对信号量的两个原子性操作，由荷兰计算机科学家 Edsger Dijkstra 于 1965 年提出 。P 操作（Proberen，意为 "尝试"）用于申请资源，V 操作（Verhogen，意为 "增加"）用于释放资源 。这两个操作就像一对紧密配合的伙伴，确保了资源的合理分配和释放。

• P 操作：当一个进程执行 P 操作时，它首先将信号量的值减 1 。如果减 1 后的结果大于等于 0，说明还有可用资源，进程可以继续执行；如果减 1 后的结果小于 0，说明资源已被全部占用，进程会被阻塞，放入等待队列中，直到有其他进程释放资源 。例如，在一个共享打印机的场景中，假设打印机资源由一个信号量 S 管理，初始值为 1。当进程 A 需要使用打印机时，它执行 P (S) 操作，此时 S 的值变为 0，进程 A 可以继续使用打印机；如果此时进程 B 也尝试使用打印机，执行 P (S) 操作后，S 的值变为 - 1，进程 B 会被阻塞，直到进程 A 使用完打印机并执行 V 操作释放资源。
• V 操作：当一个进程执行 V 操作时，它会将信号量的值加 1 。如果加 1 后的结果小于等于 0，说明有其他进程在等待资源，此时就从等待队列中唤醒一个等待的进程，让它有机会获取资源并继续执行；如果加 1 后的结果大于 0，说明没有进程在等待资源，只是增加了可用资源的数量 。例如，在上述打印机的例子中，当进程 A 使用完打印机后，执行 V (S) 操作，S 的值变为 0，此时发现有进程 B 在等待，就会唤醒进程 B，让进程 B 可以使用打印机。

PV 操作的原子性非常重要，它保证了在多进程环境下，对信号量的操作不会被中断，从而避免了竞态条件的发生。例如，在一个多进程同时访问共享资源的场景中，如果没有原子性保证，可能会出现一个进程在读取信号量的值后，还未进行减 1 操作时，另一个进程也读取了相同的信号量值，导致两个进程都认为有可用资源，从而同时访问共享资源，引发数据不一致等问题。而 PV 操作的原子性确保了这种情况不会发生，保证了系统的稳定性和正确性 。

5.3 信号量的典型应用场景

信号量在操作系统中有着广泛的应用，常用于解决各种经典的同步问题，下面是几个常见的应用场景：

• 生产者 - 消费者问题：这是信号量最经典的应用场景之一 。在这个场景中，生产者进程负责生产数据并将其放入缓冲区，消费者进程从缓冲区中取出数据进行处理 。为了避免缓冲区溢出（生产者在缓冲区满时继续生产）和空读（消费者在缓冲区空时尝试读取）的问题，需要使用信号量来进行同步 。通常会使用两个计数信号量，一个表示缓冲区中的空位置数量（初始值为缓冲区大小），另一个表示缓冲区中的数据数量（初始值为 0） 。生产者进程在生产数据前，先获取表示空位置的信号量，然后将数据放入缓冲区，再释放表示数据数量的信号量；消费者进程在读取数据前，先获取表示数据数量的信号量，然后从缓冲区中取出数据，再释放表示空位置的信号量 。例如，在一个视频采集和处理系统中，视频采集进程作为生产者，不断采集视频帧数据并放入缓冲区；视频处理进程作为消费者，从缓冲区中取出视频帧进行处理 。通过信号量的协调，可以确保采集和处理的顺利进行，避免数据丢失或错误处理 。
• 读者 - 写者问题：在这个场景中，有多个读者进程和多个写者进程，它们都需要访问共享资源 。读者进程只读取共享资源，不会对其进行修改；写者进程则会对共享资源进行写入操作 。为了保证数据的一致性，需要满足以下条件：多个读者可以同时访问共享资源；写者和其他进程（包括读者和写者）不能同时访问共享资源 。通常会使用一个互斥信号量来保证写者的独占访问，同时使用一个计数信号量来记录当前正在访问的读者数量 。当有读者进程想要访问共享资源时，先获取计数信号量，如果当前没有读者在访问，再获取互斥信号量，然后进行读取操作，读取完成后释放计数信号量；当有写者进程想要访问共享资源时，先获取互斥信号量，然后进行写入操作，写入完成后释放互斥信号量 。例如，在一个多人协作编辑文档的系统中，多个用户可以同时读取文档内容，但当有用户想要修改文档时，必须确保其他用户不能同时进行读取或修改操作，通过信号量的机制可以实现这种读写控制 。
• 哲学家就餐问题：这是一个经典的多进程同步问题，用于研究死锁和资源分配 。假设有五个哲学家围坐在一张圆桌旁，每个哲学家面前有一碗米饭和一根筷子，相邻哲学家之间共用一根筷子 。哲学家的生活状态只有两种：思考和吃饭 。吃饭时需要同时拿起左右两根筷子，吃完后放下筷子继续思考 。如果每个哲学家都同时拿起左边的筷子，那么就会出现每个哲学家都在等待右边筷子的情况，从而导致死锁 。为了解决这个问题，可以使用信号量来控制筷子的获取和释放 。例如，可以为每根筷子设置一个二元信号量，哲学家在拿起筷子前先获取对应的信号量，吃完后释放信号量 。还可以采用一些策略来避免死锁，比如最多允许四个哲学家同时拿起筷子，这样至少有一个哲学家可以拿到两根筷子吃饭，吃完后释放筷子，其他哲学家就有机会拿到筷子 。

六、信号

6.1 信号的定义与本质

信号是进程间通信机制中独特的存在，它是唯一的异步 IPC 机制 。从本质上讲，信号是用于通知进程发生异步事件的 "软件中断"。与硬件中断类似，信号会打断进程当前的正常执行流程，让进程去处理特定的事件 。不同的是，硬件中断由硬件设备触发，而信号是由软件层面产生的 。信号无需进程主动等待，它可以由多种方式生成 。比如用户在终端输入Ctrl+C，这一操作会触发SIGINT信号，通知前台进程终止运行；当进程发生段错误，访问了非法内存地址时，内核会自动生成SIGSEGV信号，告知进程出现了异常情况；进程之间也可以通过kill命令或者kill函数来发送信号，实现简单的进程间控制 。例如，在一个多进程的服务器程序中，主进程可以向子进程发送信号，通知子进程重新加载配置文件或者停止服务 。

6.2 信号的产生与处理方式

信号的产生来源广泛，除了前面提到的用户操作、内核以及进程间发送，还可以由软件条件触发，比如使用alarm函数设置定时器，当定时器到期时，会向进程发送SIGALRM信号 。当进程接收到信号后，有三种处理方式可供选择 ：

• 忽略信号：进程可以选择忽略某些信号，对其不做任何处理 。不过，SIGKILL（用于强制终止进程，对应编号 9）和SIGSTOP（用于暂停进程，对应编号 19）这两个信号是不可忽略的，它们保证了系统对进程的绝对控制权，防止出现无法终止或暂停的进程 。例如，在一些守护进程中，可能会忽略SIGINT信号，使其不会因为用户误按Ctrl+C而意外终止 。
• 执行默认操作：每个信号都有系统预设的默认操作 。比如SIGINT信号的默认操作是终止进程，当进程收到SIGINT信号且未进行自定义处理时，就会直接终止；SIGSTOP信号的默认操作是暂停进程，进程收到该信号后会进入暂停状态 。这些默认操作是操作系统为了保证系统的稳定性和一致性而设定的 。
• 注册自定义信号处理函数：进程可以通过signal函数或者sigaction函数来注册自定义的信号处理函数，当接收到指定信号时，执行用户自己编写的逻辑 。这种方式赋予了用户极大的灵活性，可以根据具体需求对信号做出针对性的响应 。例如，在一个数据处理程序中，当接收到SIGUSR1信号时，可以自定义处理函数来进行数据备份操作 。以signal函数为例，其原型为void (*signal(int signo, void (*func)(int)))(int)，第一个参数signo是信号编号，第二个参数func是指向自定义处理函数的指针 。

下面是一个简单的使用signal函数的示例代码：

#include <stdio.h>
#include <signal.h>
#include <unistd.h>


// 自定义信号处理函数
void signal_handler(int signum) {
    printf("Received signal: %d\n", signum);
}


int main() {
    // 注册SIGINT信号的处理函数
    signal(SIGINT, signal_handler);


    while (1) {
        printf("Running...\n");
        sleep(1);
    }


    return 0;
}

当程序运行时，按下Ctrl+C产生SIGINT信号，就会调用signal_handler函数，输出接收到的信号编号 。

6.3 常见信号与应用场景

在操作系统中，有许多常见的信号，它们各自有着特定的用途和应用场景 ：

• SIGINT：中断信号，对应Ctrl+C组合键 。在用户希望终止一个正在运行的前台进程时，通常会使用Ctrl+C触发SIGINT信号 。比如在命令行中运行一个长时间运行的脚本，当用户不想继续执行时，按下Ctrl+C，脚本进程就会收到SIGINT信号，然后根据其处理方式决定是终止还是进行其他操作 。
• SIGTERM：终止信号，对应kill命令的默认信号 。SIGTERM信号通常用于正常终止一个进程，它给予进程一定的时间来进行资源清理和收尾工作 。例如，在关闭一个服务器程序时，可以发送SIGTERM信号，服务器程序接收到信号后，会关闭正在监听的端口，保存未处理完的数据，然后优雅地退出 。
• SIGSEGV：段错误信号，当进程访问非法内存地址，如空指针解引用、数组越界访问等情况时，内核会向进程发送SIGSEGV信号 。在开发和调试程序时，SIGSEGV信号是一个重要的错误提示，通过分析产生SIGSEGV信号的代码位置，可以定位和修复程序中的内存错误 。

信号在操作系统中有着广泛的应用场景 。在进程异常处理方面，通过捕获SIGSEGV等信号，可以在程序出现内存错误时，进行错误日志记录或者尝试进行一些恢复操作，避免程序直接崩溃导致数据丢失 。在需要强制终止某个进程时，SIGKILL信号可以确保进程被立即终止，即使进程处于异常状态也能生效 。对于一些定时任务，如定时备份数据、定时清理临时文件等，可以利用alarm函数和SIGALRM信号来实现定时通知，让进程在特定的时间点执行相应的任务 。

七、Socket

7.1 Socket 的定义与核心作用

Socket（套接字）是基于 TCP/IP 协议的通信接口，突破了单机 IPC 的限制，既能实现同一主机的进程通信，也能实现不同主机跨网络的进程通信，是网络编程的核心技术。它就像网络世界中的一个 "超级信箱"，每个进程都可以通过它与其他进程交换信件（数据），无论是在同一台主机上还是在不同的主机上，只要它们处于同一个网络中。比如，在一个分布式系统中，不同服务器上的进程需要协同工作，就可以借助 Socket 进行通信。像电商系统中的订单处理进程和库存管理进程，可能分别部署在不同的服务器上，它们通过 Socket 建立连接，订单处理进程在生成订单后，将订单信息通过 Socket 发送给库存管理进程，库存管理进程接收信息后更新库存，实现了跨主机的进程间协作。

7.2 Socket 的通信模型

Socket 支持 TCP 和 UDP 两种通信模型，TCP 是面向连接的可靠通信，基于 "三次握手" 建立连接，保证数据有序、不丢失，适合大数据传输；UDP 是无连接的不可靠通信，无需建立连接，传输效率高，适合实时性要求高的场景（如音视频传输）。以文件传输为例，当我们从服务器上下载一个大型文件时，通常会使用 TCP 协议，因为它能确保文件的每一个字节都准确无误地传输到我们的设备上，不会出现数据丢失或乱序的情况。而在视频会议中，由于对实时性要求极高，即使偶尔丢失一些数据帧对观看效果影响不大，所以会采用 UDP 协议，它能快速地将视频数据传输到接收端，保证视频的流畅播放。

7.3 Socket 与其他 IPC 机制的区别

与管道、共享内存等单机 IPC 机制不同，Socket 的核心优势是支持跨主机通信；其劣势是需封装底层网络协议，通信效率低于单机 IPC 机制，且编程复杂度更高，需指定 IP 地址和端口号实现进程寻址。在同一台主机上，使用管道进行进程间通信就像在同一栋楼里的不同房间之间传递物品，简单直接，不需要考虑太多复杂的网络配置。而 Socket 则像是不同城市的两栋楼之间传递物品，需要经过复杂的物流网络（网络协议），还要明确收件人的详细地址（IP 地址和端口号）。而且由于网络传输的不确定性，Socket 通信的效率往往低于单机 IPC 机制。比如在一个本地文件处理系统中，使用共享内存可以快速地在不同进程间传递文件数据，而如果通过 Socket 进行通信，由于网络延迟和协议开销，数据传输的速度会明显变慢。

八、总结

8.1 六大进程通信机制核心对比

从通信效率来看，共享内存独占鳌头，由于它直接在内存中共享数据，无需数据拷贝，数据传输速度极快，在需要频繁传输大量数据的场景中优势明显。管道基于内核缓冲区，数据传输效率也相对较高，不过它在读写时会涉及一定的系统调用开销。消息队列通过内核维护的消息链表进行数据传递，读写操作时需要在用户态和内核态之间进行数据拷贝，效率低于管道。Socket 由于需要封装底层网络协议，并且可能涉及网络传输，其通信效率相对较低，特别是在跨网络通信时，受网络延迟等因素影响较大。信号量主要用于进程同步，本身不直接传输数据，所以在数据传输效率方面表现较弱。信号作为异步通信机制，主要用于事件通知，数据携带能力有限，通信效率相对较低。

从适用场景来看，共享内存适用于单机环境下对通信效率要求极高、数据量较大的场景，如大数据处理、实时视频处理等；管道常用于具有亲缘关系进程间的简单数据传输，如父子进程间的通信，在 Shell 命令管道中也有广泛应用；消息队列适用于需要异步解耦的场景，如微服务架构中的消息传递、订单状态通知等；信号量主要用于控制多个进程对共享资源的访问，实现进程同步，如数据库连接池管理、多进程日志写入控制等；信号常用于异步事件通知，如进程优雅终止、系统异常处理等；Socket 则适用于跨主机的进程通信，无论是分布式系统中的服务间通信，还是网络应用中的客户端与服务器通信，都离不开 Socket。

8.2 进程通信机制选型原则

遵循三大原则： 一是根据数据量大小选择合适机制，小数据量用信号、管道，大数据量用共享内存、Socket。当进程间需要传递的数据量较小，比如只是简单的状态通知、控制命令等，信号和管道就能很好地胜任。信号可以快速地通知进程某个事件的发生，而管道则能简单高效地传递少量数据。但如果数据量较大，像视频文件、大型数据库查询结果等，共享内存和 Socket 就更为合适。共享内存通过直接在内存中共享数据，大大提高了数据传输的效率；Socket 则能满足跨主机传输大数据的需求。

二是区分单机与跨网络、同步与异步场景。单机同步场景选管道、共享内存；单机异步场景选消息队列、信号；跨网络通信则用 Socket。在单机环境中，如果进程间的通信是同步进行的，即一个进程等待另一个进程完成操作后再继续执行，管道和共享内存是不错的选择。管道可以实现简单的同步数据传输，而共享内存则能在高并发场景下保证数据的快速传输和共享。如果是异步通信，消息队列和信号则能发挥更大的作用。消息队列可以实现异步解耦，让发送和接收进程无需实时等待；信号则能及时通知进程异步事件的发生。而当涉及跨网络通信时，Socket 凭借其基于 TCP/IP 协议的特性，成为了不二之选。

三是根据可靠性与实时性需求选择。高可靠场景选 TCP Socket、消息队列，实时性场景选 UDP Socket、信号。在对可靠性要求极高的场景中，比如金融交易系统、文件传输等，TCP Socket 和消息队列是首选。TCP Socket 通过三次握手和重传机制，确保数据的可靠传输；消息队列则能保证消息不会丢失，即使在接收进程繁忙或出现故障时，消息也能在队列中等待处理。而对于实时性要求较高的场景，如视频会议、实时游戏等，UDP Socket 和信号更能满足需求。UDP Socket 无需建立连接，传输速度快，虽然存在一定的数据丢失风险，但在实时性要求高于可靠性的场景中是可以接受的；信号则能实现即时的事件通知，确保进程能及时响应实时事件。