HTTP服务器项目2：Linux多进程开发

墨蓝 2022-11-11 05:29 218阅读 0赞

## HTTP服务器项目2：Linux多进程开发 ##

**1.进程概述：**

**01 / 程序和进程**

程序是包含一系列信息的文件，这些信息描述了如何在运行时创建一个进程：

◼ 二进制格式标识：每个程序文件都包含用于描述可执行文件格式的元信息。内核利用此信息来解释文件中的其他信息。（ELF可执行连接格式）  
◼ 机器语言指令：对程序算法进行编码。  
◼ 程序入口地址：标识程序开始执行时的起始指令位置。  
◼ 数据：程序文件包含的变量初始值和程序使用的字面量值（比如字符串）。  
◼ 符号表及重定位表：描述程序中函数和变量的位置及名称。这些表格有多重用途，其中包括调试和运行时的符号解析（动态链接）。  
◼ 共享库和动态链接信息：程序文件所包含的一些字段，列出了程序运行时需要使用的共享库，以及加载共享库的动态连接器的路径名。  
◼ 其他信息：程序文件还包含许多其他信息，用以描述如何创建进程。

◼ 进程是正在运行的程序的实例。是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。  
◼ 可以用一个程序来创建多个进程，进程是由内核定义的抽象实体，并为该实体分配用以执行程序的各项系统资源。从内核的角度看，进程由用户内存空间和一系列内核数据结构组成，其中用户内存空间包含了程序代码及代码所使用的变量，而内核数据结构则用于维护进程状态信息。记录在内核数据结构中的信息包括许多与进程相关的标  
识号（IDs）、虚拟内存表、打开文件的描述符表、信号传递及处理的有关信息、进程资源使用及限制、当前工作目录和大量的其他信息。

**02 / 单道、多道程序设计**

◼ 单道程序，即在计算机内存中只允许一个的程序运行。  
◼ 多道程序设计技术是在计算机内存中同时存放几道相互独立的程序，使它们在管理程序控制下，相互穿插运行，两个或两个以上程序在计算机系统中同处于开始到结束之间的状态, 这些程序共享计算机系统资源。引入多道程序设计技术的根本目的是为了提高 CPU 的利用率。

◼ 对于一个单 CPU 系统来说，程序同时处于运行状态只是一种宏观上的概念，他们虽然都已经开始运行，但就微观而言，任意时刻，CPU 上运行的程序只有一个。  
◼ 在多道程序设计模型中，多个进程轮流使用 CPU。而当下常见 CPU 为纳秒级，1秒可以执行大约 10 亿条指令。由于人眼的反应速度是毫秒级，所以看似同时在运行。

**03 / 时间片**

◼ 时间片（timeslice）又称为“量子（quantum）”或“处理器片（processor slice）”是操作系统分配给每个正在运行的进程微观上的一段 CPU 时间。事实上，虽然一台计算机通常可能有多个 CPU，但是同一个 CPU 永远不可能真正地同时运行多个任务。在只考虑一个 CPU 的情况下，这些进程“看起来像”同时运行的，实则是轮番穿插地运行，由于时间片通常很短（在 Linux 上为 5ms－800ms），用户不会感觉到。

◼ 时间片由操作系统内核的调度程序分配给每个进程。首先，内核会给每个进程分配相等的初始时间片，然后每个进程轮番地执行相应的时间，当所有进程都处于时间片耗尽的状态时，内核会重新为每个进程计算并分配时间片，如此往复。

**04 / 并行和并发**

◼ 并行(parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。  
◼ 并发(concurrency)：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70]  
◼ 并发是两个队列交替使用一台咖啡机。  
◼ 并行是两个队列同时使用两台咖啡机。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 1]  
**05 / 进程控制块（PCB）**

◼ 为了管理进程，内核必须对每个进程所做的事情进行清楚的描述。内核为每个进程分配一个 PCB(Processing Control Block)进程控制块，维护进程相关的信息，Linux 内核的进程控制块是task\_struct结构体。  
◼ 在 /usr/src/linux-headers-xxx/include/linux/sched.h 文件中可以查  
看 struct task\_struct 结构体定义。其内部成员有很多，我们只需要掌握以下  
部分即可：

> ⚫ 进程id：系统中每个进程有唯一的 id，用 pid\_t 类型表示，其实就是一个非负整数  
> ⚫ 进程的状态：有就绪、运行、挂起、停止等状态  
> ⚫ 进程切换时需要保存和恢复的一些CPU寄存器  
> ⚫ 描述虚拟地址空间的信息  
> ⚫ 描述控制终端的信息  
> ⚫ 当前工作目录（Current Working Directory） ⚫ umask 掩码  
> ⚫ 文件描述符表，包含很多指向 file 结构体的指针  
> ⚫ 和信号相关的信息  
> ⚫ 用户 id 和组 id  
> ⚫ 会话（Session）和进程组  
> ⚫ 进程可以使用的资源上限（Resource Limit）

**2.进程状态转换:**

**01 / 进程的状态**

进程状态反映进程执行过程的变化。这些状态随着进程的执行和外界条件的变化而转换。  
在三态模型中，进程状态分为三个基本状态，即就绪态，运行态，阻塞态。在五态模型中，进程分为新建态、就绪态，运行态，阻塞态，终止态。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 2]  
◼ 运行态：进程占有处理器正在运行  
◼ 就绪态：进程具备运行条件，等待系统分配处理器以便运  
行。当进程已分配到除CPU以外的所有必要资源后，只要再  
获得CPU，便可立即执行。在一个系统中处于就绪状态的进  
程可能有多个，通常将它们排成一个队列，称为就绪队列  
◼ 阻塞态：又称为等待(wait)态或睡眠(sleep)态，指进程  
不具备运行条件，正在等待某个事件的完成

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 3]  
◼ 新建态：进程刚被创建时的状态，尚未进入就绪队列  
◼ 终止态：进程完成任务到达正常结束点，或出现无法克服的错误而异常终止，或被操作系统及有终止权的进程所终止时所处的状态。进入终止态的进程以后不再执行，但依然保留在操作系统中等待善后。一旦其他进程完成了对终止态进程的信息抽取之后，操作系统将删除该进程。

**02 / 进程相关命令**

◼ 查看进程:

ps aux / ajx
    a：显示终端上的所有进程，包括其他用户的进程
    u：显示进程的详细信息
    x：显示没有控制终端的进程
    j：列出与作业控制相关的信息

◼ STAT参数意义：

D ----不可中断 Uninterruptible（usually IO） R 正在运行，或在队列中的进程
    S ----(大写) 处于休眠状态
    T ----停止或被追踪
    Z ----僵尸进程
    W ----进入内存交换（从内核2.6开始无效）
    X ----死掉的进程
    < ----高优先级
    N ----低优先级
    s ----包含子进程
    + ----位于前台的进程组

◼ 实时显示进程动态

top  
可以在使用 top 命令时加上 -d 来指定显示信息更新的时间间隔，在 top 命令  
执行后，可以按以下按键对显示的结果进行排序：  
⚫ M 根据内存使用量排序  
⚫ P 根据 CPU 占有率排序  
⚫ T 根据进程运行时间长短排序  
⚫ U 根据用户名来筛选进程  
⚫ K 输入指定的 PID 杀死进程

◼ 杀死进程

kill [-signal] pid
    kill –l 列出所有信号
    kill –SIGKILL 进程ID
    kill -9 进程ID
    
    killall name 根据进程名杀死进程

**03 / 进程号和相关函数**

◼ 每个进程都由进程号来标识，其类型为 pid\_t（整型），进程号的范围：0～32767。进程号总是唯一的，但可以重用。当一个进程终止后，其进程号就可以再次使用。  
◼ 任何进程（除 init 进程）都是由另一个进程创建，该进程称为被创建进程的父进程，对应的进程号称为父进程号（PPID）。  
◼ 进程组是一个或多个进程的集合。他们之间相互关联，进程组可以接收同一终端的各种信号，关联的进程有一个进程组号（PGID）。默认情况下，当前的进程号会当做当前的进程组号。

◼ 进程号和进程组相关函数：

⚫ pid_t getpid(void);
    ⚫ pid_t getppid(void);
    ⚫ pid_t getpgid(pid_t pid);

**3.进程创建：**

**01 / 进程创建**  
系统允许一个进程创建新进程，新进程即为子进程，子进程还可以创建新的子进程，形成进程树结构模型。

#include <sys/types.h>
    #include <unistd.h>
    pid_t fork(void);

返回值：  
⚫ 成功：子进程中返回 0，父进程中返回子进程 ID  
⚫ 失败：返回 -1  
失败的两个主要原因：

1.  当前系统的进程数已经达到了系统规定的上限，这时 errno 的值被设置为 EAGAIN
2.  系统内存不足，这时 errno 的值被设置为 ENOMEM

**02 / 父子进程虚拟地址空间**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 4]  
fork()以后，子进程的用户区数据和父进程一样，内核区也会拷贝过来，但是pid发生了改变。效果相当于克隆，为写时拷贝；

在这里插入图片描述  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 5]  
代码演示：

/*
        #include <sys/types.h>
        #include <unistd.h>
    
        pid_t fork(void);
            函数的作用：用于创建子进程。
            返回值：
                fork()的返回值会返回两次。一次是在父进程中，一次是在子进程中。
                在父进程中返回创建的子进程的ID,
                在子进程中返回0
                如何区分父进程和子进程：通过fork的返回值。
                在父进程中返回-1，表示创建子进程失败，并且设置errno
    
            父子进程之间的关系：
            区别：
                1.fork()函数的返回值不同
                    父进程中: >0 返回的子进程的ID
                    子进程中: =0
                2.pcb中的一些数据
                    当前的进程的id pid
                    当前的进程的父进程的id ppid
                    信号集
    
            共同点：
                某些状态下：子进程刚被创建出来，还没有执行任何的写数据的操作
                    - 用户区的数据
                    - 文件描述符表
            
            父子进程对变量是不是共享的？
                - 刚开始的时候，是一样的，共享的。如果修改了数据，不共享了。
                - 读时共享（子进程被创建，两个进程没有做任何的写的操作），写时拷贝。
            
    */
    
    #include <sys/types.h>
    #include <unistd.h>
    #include <stdio.h>
    
    int main() {
        
    
        int num = 10;
    
        // 创建子进程
        pid_t pid = fork();
    
        // 判断是父进程还是子进程
        if(pid > 0) {
        
            // printf("pid : %d\n", pid);
            // 如果大于0，返回的是创建的子进程的进程号，当前是父进程
            printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());
    
            printf("parent num : %d\n", num);
            num += 10;
            printf("parent num += 10 : %d\n", num);
    
    
        } else if(pid == 0) {
        
            // 当前是子进程
            printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid());
           
            printf("child num : %d\n", num);
            num += 100;
            printf("child num += 100 : %d\n", num);
        }
    
        // for循环
        for(int i = 0; i < 3; i++) {
        
            printf("i : %d , pid : %d\n", i , getpid());
            sleep(1);
        }
    
        return 0;
    }
    
    /*
    实际上，更准确来说，Linux 的 fork() 使用是通过写时拷贝 (copy- on-write) 实现。
    写时拷贝是一种可以推迟甚至避免拷贝数据的技术。
    内核此时并不复制整个进程的地址空间，而是让父子进程共享同一个地址空间。
    只用在需要写入的时候才会复制地址空间，从而使各个进行拥有各自的地址空间。
    也就是说，资源的复制是在需要写入的时候才会进行，在此之前，只有以只读方式共享。
    注意：fork之后父子进程共享文件，
    fork产生的子进程与父进程相同的文件文件描述符指向相同的文件表，引用计数增加，共享文件偏移指针。
    */

父子进程之间的关系：  
参考代码：

#include <stdio.h>
    #include <unistd.h>
    
    int main() {
        
    
        printf("begin\n");
    
        if(fork() > 0) {
        
    
            printf("我是父进程：pid = %d, ppid = %d\n", getpid(), getppid());
    
            int i;
            for(i = 0; i < 10; i++) {
        
                printf("i = %d\n", i);
                sleep(1);
            }
    
        } else {
        
    
            printf("我是子进程：pid = %d, ppid = %d\n", getpid(), getppid());
            
            int j;
            for(j = 0; j < 10; j++) {
        
                printf("j = %d\n", j);
                sleep(1);
            }
    
        }
    
        return 0;
    }

**03 / GDB 多进程调试**

使用 GDB 调试的时候，GDB 默认只能跟踪一个进程，可以在 fork 函数调用之前，通过指令设置 GDB 调试工具跟踪父进程或者是跟踪子进程，默认跟踪父进程。

设置调试父进程或者子进程：

set follow-fork-mode [parent（默认）| child]

查看调试父进程或者子进程：

show follow-fork-mode

设置调试模式：

set detach-on-fork [on | off]

默认为 on，表示调试当前进程的时候，其它的进程继续运行，如果为 off，调试当前进程的时候，其它进程被 GDB 挂起。

> 查看调试的进程：info inferiors  
> 切换当前调试的进程：inferior id  
> 使进程脱离 GDB 调试：detach inferiors id

**4.exec函数族：**

**01 / exec 函数族介绍**

◼ exec 函数族的作用是根据指定的文件名找到可执行文件，并用它来取代调用进程的内容，换句话说，就是在调用进程内部执行一个可执行文件。

◼ exec 函数族的函数执行成功后不会返回，因为调用进程的实体，包括代码段，数据段和堆栈等都已经被新的内容取代，只留下进程 ID 等一些表面上的信息仍保持原样，颇有些神似“三十六计”中的“金蝉脱壳”。看上去还是旧的躯壳，却已经注入了新的灵魂。只有调用失败了，它们才会返回 -1，从原程序的调用点接着往下执行。

**02 / exec 函数族作用图解**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 6]  
**03 / exec 函数族**

> ◼ int execl(const char \*path, const char *arg, …/* (char \*) NULL \*/);  
> ◼ int execlp(const char \*file, const char *arg, … /* (char \*) NULL \*/);  
> ◼ int execle(const char \*path, const char *arg, …/*, (char \*) NULL, char \*  
> const envp\[\] \*/);  
> ◼ int execv(const char \*path, char \*const argv\[\]);  
> ◼ int execvp(const char \*file, char \*const argv\[\]);  
> ◼ int execvpe(const char \*file, char \*const argv\[\], char \*const envp\[\]);  
> ◼ int execve(const char \*filename, char \*const argv\[\], char \*const envp\[\]);  
> l(list) 参数地址列表，以空指针结尾  
> v(vector) 存有各参数地址的指针数组的地址  
> p(path) 按 PATH 环境变量指定的目录搜索可执行文件  
> e(environment) 存有环境变量字符串地址的指针数组的地址

代码演示：  
测试代码：hello.c

#include <stdio.h>
    
    int main() {
            
    
        printf("hello, world\n");
    
        return 0;
    }

execl.c

/*  
        #include <unistd.h>
        int execl(const char *path, const char *arg, ...);
            - 参数：
                - path:需要指定的执行的文件的路径或者名称
                    a.out /home/nowcoder/a.out 推荐使用绝对路径
                    ./a.out hello world
    
                - arg:是执行可执行文件所需要的参数列表
                    第一个参数一般没有什么作用，为了方便，一般写的是执行的程序的名称
                    从第二个参数开始往后，就是程序执行所需要的的参数列表。
                    参数最后需要以NULL结束（哨兵）
    
            - 返回值：
                只有当调用失败，才会有返回值，返回-1，并且设置errno
                如果调用成功，没有返回值。
    
    */
    #include <unistd.h>
    #include <stdio.h>
    
    int main() {
        
    
    
        // 创建一个子进程，在子进程中执行exec函数族中的函数
        pid_t pid = fork();
    
        if(pid > 0) {
        
            // 父进程
            printf("i am parent process, pid : %d\n",getpid());
            sleep(1);
        }else if(pid == 0) {
        
            // 子进程
            // execl("hello","hello",NULL);
    
            execl("/bin/ps", "ps", "aux", NULL);
            perror("execl");
            printf("i am child process, pid : %d\n", getpid());
    
        }
    
        for(int i = 0; i < 3; i++) {
        
            printf("i = %d, pid = %d\n", i, getpid());
        }
    
    
        return 0;
    }

execlp.c

/*  
        #include <unistd.h>
        int execlp(const char *file, const char *arg, ... );
            - 会到环境变量中查找指定的可执行文件，如果找到了就执行，找不到就执行不成功。
            - 参数：
                - file:需要执行的可执行文件的文件名
                    a.out
                    ps
    
                - arg:是执行可执行文件所需要的参数列表
                    第一个参数一般没有什么作用，为了方便，一般写的是执行的程序的名称
                    从第二个参数开始往后，就是程序执行所需要的的参数列表。
                    参数最后需要以NULL结束（哨兵）
    
            - 返回值：
                只有当调用失败，才会有返回值，返回-1，并且设置errno
                如果调用成功，没有返回值。
    
    
            int execv(const char *path, char *const argv[]);
            argv是需要的参数的一个字符串数组
            char * argv[] = {"ps", "aux", NULL};
            execv("/bin/ps", argv);
    
            int execve(const char *filename, char *const argv[], char *const envp[]);
            char * envp[] = {"/home/nowcoder", "/home/bbb", "/home/aaa"};
    
    
    */
    #include <unistd.h>
    #include <stdio.h>
    
    int main() {
        
    
    
        // 创建一个子进程，在子进程中执行exec函数族中的函数
        pid_t pid = fork();
    
        if(pid > 0) {
        
            // 父进程
            printf("i am parent process, pid : %d\n",getpid());
            sleep(1);
        }else if(pid == 0) {
        
            // 子进程
            execlp("ps", "ps", "aux", NULL);
    
            printf("i am child process, pid : %d\n", getpid());
    
        }
    
        for(int i = 0; i < 3; i++) {
        
            printf("i = %d, pid = %d\n", i, getpid());
        }
    
    
        return 0;
    }

**5.进程控制**

**01 / 进程退出**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 7]  
代码演示：

/*
        #include <stdlib.h>
        void exit(int status);
    
        #include <unistd.h>
        void _exit(int status);
    
        status参数：是进程退出时的一个状态信息。父进程回收子进程资源的时候可以获取到。
    */
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    int main() {
        
    
        printf("hello\n");
        printf("world");
    
        // exit(0);
        _exit(0);
        
        return 0;
    }

**02 / 孤儿进程**

◼ 父进程运行结束，但子进程还在运行（未运行结束），这样的子进程就称为孤儿进程（Orphan Process）。  
◼ 每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为 init ，而 init 进程会循环地 wait() 它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init 进程就会代表党和政府出面处理它的一切善后工作。  
◼ 因此孤儿进程并不会有什么危害。

代码演示：  
orphan.c

#include <sys/types.h>
    #include <unistd.h>
    #include <stdio.h>
    
    int main() {
        
    
        // 创建子进程
        pid_t pid = fork();
    
        // 判断是父进程还是子进程
        if(pid > 0) {
        
    
            printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());
    
        } else if(pid == 0) {
        
            sleep(1);
            // 当前是子进程
            printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid());
           
        }
    
        // for循环
        for(int i = 0; i < 3; i++) {
        
            printf("i : %d , pid : %d\n", i , getpid());
        }
    
        return 0;
    }

**03 / 僵尸进程**

◼ 每个进程结束之后, 都会释放自己地址空间中的用户区数据，内核区的 PCB 没有办法自己释放掉，需要父进程去释放。  
◼ 进程终止时，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸  
（Zombie）进程。  
◼ 僵尸进程不能被 kill -9 杀死，这样就会导致一个问题，如果父进程不调用 wait() 或 waitpid() 的话，那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵尸进程，将因为没有可用的进程号而导致系统不能产生新的进程，此即为僵尸进程的危害，应当避免。

代码演示：  
zombie.c

#include <sys/types.h>
    #include <unistd.h>
    #include <stdio.h>
    
    int main() {
        
    
        // 创建子进程
        pid_t pid = fork();
    
        // 判断是父进程还是子进程
        if(pid > 0) {
        
            while(1) {
        
                printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());
                sleep(1);
            }
    
        } else if(pid == 0) {
        
            // 当前是子进程
            printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid());
           
        }
    
        // for循环
        for(int i = 0; i < 3; i++) {
        
            printf("i : %d , pid : %d\n", i , getpid());
        }
    
        return 0;
    }

**04 / 进程回收**

◼ 在每个进程退出的时候，内核释放该进程所有的资源、包括打开的文件、占用的内存等。但是仍然为其保留一定的信息，这些信息主要主要指进程控制块PCB的信息（包括进程号、退出状态、运行时间等）。  
◼ 父进程可以通过调用wait或waitpid得到它的退出状态同时彻底清除掉这个进程。  
◼ wait() 和 waitpid() 函数的功能一样，区别在于，wait() 函数会阻塞，waitpid() 可以设置不阻塞，waitpid() 还可以指定等待哪个子进程结束。

◼ 注意：一次wait或waitpid调用只能清理一个子进程，清理多个子进程应使用循环。

**05 / 退出信息相关宏函数**

> ◼ WIFEXITED(status) 非0，进程正常退出  
> ◼ WEXITSTATUS(status) 如果上宏为真，获取进程退出的状态（exit的参数）  
> ◼ WIFSIGNALED(status) 非0，进程异常终止  
> ◼ WTERMSIG(status) 如果上宏为真，获取使进程终止的信号编号  
> ◼ WIFSTOPPED(status) 非0，进程处于暂停状态  
> ◼ WSTOPSIG(status) 如果上宏为真，获取使进程暂停的信号的编号  
> ◼ WIFCONTINUED(status) 非0，进程暂停后已经继续运行

参考代码：  
wait.c

/*
        #include <sys/types.h>
        #include <sys/wait.h>
        pid_t wait(int *wstatus);
            功能：等待任意一个子进程结束，如果任意一个子进程结束了，次函数会回收子进程的资源。
            参数：int *wstatus
                进程退出时的状态信息，传入的是一个int类型的地址，传出参数。
            返回值：
                - 成功：返回被回收的子进程的id
                - 失败：-1 (所有的子进程都结束，调用函数失败)
    
        调用wait函数的进程会被挂起（阻塞），直到它的一个子进程退出或者收到一个不能被忽略的信号时才被唤醒（相当于继续往下执行）
        如果没有子进程了，函数立刻返回，返回-1；如果子进程都已经结束了，也会立即返回，返回-1.
    
    */
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    
    int main() {
        
    
        // 有一个父进程，创建5个子进程（兄弟）
        pid_t pid;
    
        // 创建5个子进程
        for(int i = 0; i < 5; i++) {
        
            pid = fork();
            if(pid == 0) {
        
                break;
            }
        }
    
        if(pid > 0) {
        
            // 父进程
            while(1) {
        
                printf("parent, pid = %d\n", getpid());
    
                // int ret = wait(NULL);
                int st;
                int ret = wait(&st);
    
                if(ret == -1) {
        
                    break;
                }
    
                if(WIFEXITED(st)) {
        
                    // 是不是正常退出
                    printf("退出的状态码：%d\n", WEXITSTATUS(st));
                }
                if(WIFSIGNALED(st)) {
        
                    // 是不是异常终止
                    printf("被哪个信号干掉了：%d\n", WTERMSIG(st));
                }
    
                printf("child die, pid = %d\n", ret);
    
                sleep(1);
            }
    
        } else if (pid == 0){
        
            // 子进程
             while(1) {
        
                printf("child, pid = %d\n",getpid());    
                sleep(1);       
             }
    
            exit(0);
        }
    
        return 0; // exit(0)
    }

waitpid.c

/*
        #include <sys/types.h>
        #include <sys/wait.h>
        pid_t waitpid(pid_t pid, int *wstatus, int options);
            功能：回收指定进程号的子进程，可以设置是否阻塞。
            参数：
                - pid:
                    pid > 0 : 某个子进程的pid
                    pid = 0 : 回收当前进程组的所有子进程    
                    pid = -1 : 回收所有的子进程，相当于 wait()  （最常用）
                    pid < -1 : 某个进程组的组id的绝对值，回收指定进程组中的子进程
                - options：设置阻塞或者非阻塞
                    0 : 阻塞
                    WNOHANG : 非阻塞
                - 返回值：
                    > 0 : 返回子进程的id
                    = 0 : options=WNOHANG, 表示还有子进程或者
                    = -1 ：错误，或者没有子进程了
    */
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    int main() {
        
    
        // 有一个父进程，创建5个子进程（兄弟）
        pid_t pid;
    
        // 创建5个子进程
        for(int i = 0; i < 5; i++) {
        
            pid = fork();
            if(pid == 0) {
        
                break;
            }
        }
    
        if(pid > 0) {
        
            // 父进程
            while(1) {
        
                printf("parent, pid = %d\n", getpid());
                sleep(1);
    
                int st;
                // int ret = waitpid(-1, &st, 0);
                int ret = waitpid(-1, &st, WNOHANG);
    
                if(ret == -1) {
        
                    break;
                } else if(ret == 0) {
        
                    // 说明还有子进程存在
                    continue;
                } else if(ret > 0) {
        
    
                    if(WIFEXITED(st)) {
        
                        // 是不是正常退出
                        printf("退出的状态码：%d\n", WEXITSTATUS(st));
                    }
                    if(WIFSIGNALED(st)) {
        
                        // 是不是异常终止
                        printf("被哪个信号干掉了：%d\n", WTERMSIG(st));
                    }
    
                    printf("child die, pid = %d\n", ret);
                }
               
            }
    
        } else if (pid == 0){
        
            // 子进程
             while(1) {
        
                printf("child, pid = %d\n",getpid());    
                sleep(1);       
             }
            exit(0);
        }
    
        return 0; 
    }

**6.进程间通信**

**01 / 进程间通讯概念**

◼ 进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。  
◼ 但是，进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程  
间通信( IPC：Inter Processes Communication )。

◼ **进程间通信的目的：**  
◼ 数据传输：一个进程需要将它的数据发送给另一个进程。  
◼ 通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。  
◼ 资源共享：多个进程之间共享同样的资源。为了做到这一点，需要内核提供互斥和同步机制。  
◼ 进程控制：有些进程希望完全控制另一个进程的执行（如 Debug 进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

**02 / Linux 进程间通信的方式**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 8]  
**03 / 匿名管道**

◼ 管道也叫无名（匿名）管道，它是是 UNIX 系统 IPC（进程间通信）的最古老形式，所有的 UNIX 系统都支持这种通信机制。

◼ 统计一个目录中文件的数目命令：ls | wc –l，为了执行该命令，shell 创建了两个进程来分别执行 ls 和 wc。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 9]  
**04 / 管道的特点**

◼ 管道其实是一个在内核内存中维护的缓冲器，这个缓冲器的存储能力是有限的，不同的操作系统大小不一定相同。  
◼ 管道拥有文件的特质：读操作、写操作，匿名管道没有文件实体，有名管道有文件实体，但不存储数据。可以按照操作文件的方式对管道进行操作。  
◼ 一个管道是一个字节流，使用管道时不存在消息或者消息边界的概念，从管道读取数据的进程可以读取任意大小的数据块，而不管写入进程写入管道的数据块的大小是多少。  
◼ 通过管道传递的数据是顺序的，从管道中读取出来的字节的顺序和它们被写入管道的顺序是完全一样的。  
◼ 在管道中的数据的传递方向是单向的，一端用于写入，一端用于读取，管道是半双工的。  
◼ 从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写更多的数据，在管道中无法使用 lseek() 来随机的访问数据。  
◼ 匿名管道只能在具有公共祖先的进程（父进程与子进程，或者两个兄弟进程，具有亲缘关系）之间使用。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 10]  
**05 / 为什么可以使用管道进行进程间通信**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 11]  
亲缘关系的进程之间共享文件描述符，所以能够进行管道之间的通信；

**06 / 管道的数据结构**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 12]  
环形队列相较于直行队列的优点是：使空间得以重复利用；

**07 / 匿名管道的使用**

◼ 创建匿名管道

#include <unistd.h>
    int pipe(int pipefd[2]);

◼ 查看管道缓冲大小命令

ulimit –a

◼ 查看管道缓冲大小函数

#include <unistd.h>
    long fpathconf(int fd, int name);

案例一：父子进程之间通过管道进行单向通信；

/*
        #include <unistd.h>
        int pipe(int pipefd[2]);
            功能：创建一个匿名管道，用来进程间通信。
            参数：int pipefd[2] 这个数组是一个传出参数。
                pipefd[0] 对应的是管道的读端
                pipefd[1] 对应的是管道的写端
            返回值：
                成功 0
                失败 -1
    
        管道默认是阻塞的：如果管道中没有数据，read阻塞，如果管道满了，write阻塞
    
        注意：匿名管道只能用于具有关系的进程之间的通信（父子进程，兄弟进程）
    */
    
    // 子进程发送数据给父进程，父进程读取到数据输出
    #include <unistd.h>
    #include <sys/types.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    int main() {
        
    
        // 在fork之前创建管道
        int pipefd[2];
        int ret = pipe(pipefd);
        if(ret == -1) {
        
            perror("pipe");
            exit(0);
        }
    
        // 创建子进程
        pid_t pid = fork();
        if(pid > 0) {
        
            // 父进程
            printf("i am parent process, pid : %d\n", getpid());
    
            // 关闭写端
            close(pipefd[1]);
            
            // 从管道的读取端读取数据
            char buf[1024] = {
        0};
            while(1) {
        
                int len = read(pipefd[0], buf, sizeof(buf));
                printf("parent recv : %s, pid : %d\n", buf, getpid());
                
                // 向管道中写入数据
                //char * str = "hello,i am parent";
                //write(pipefd[1], str, strlen(str));
                //sleep(1);
            }
    
        } else if(pid == 0){
        
            // 子进程
            printf("i am child process, pid : %d\n", getpid());
            // 关闭读端
            close(pipefd[0]);
            char buf[1024] = {
        0};
            while(1) {
        
                // 向管道中写入数据
                char * str = "hello,i am child";
                write(pipefd[1], str, strlen(str));
                //sleep(1);
    
                // int len = read(pipefd[0], buf, sizeof(buf));
                // printf("child recv : %s, pid : %d\n", buf, getpid());
                // bzero(buf, 1024);
            }
            
        }
        return 0;
    }

案例二：计算管道的大小；

#include <unistd.h>
    #include <sys/types.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    int main() {
        
    
        int pipefd[2];
    
        int ret = pipe(pipefd);
    
        // 获取管道的大小
        long size = fpathconf(pipefd[0], _PC_PIPE_BUF);
    
        printf("pipe size : %ld\n", size);
    
        return 0;
    }

案例三：匿名管道通信案例：

/*
        实现 ps aux | grep xxx 父子进程间通信
        
        子进程： ps aux, 子进程结束后，将数据发送给父进程
        父进程：获取到数据，过滤
        pipe()
        execlp()
        子进程将标准输出 stdout_fileno 重定向到管道的写端。  dup2
    */
    
    #include <unistd.h>
    #include <sys/types.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <wait.h>
    
    int main() {
        
    
        // 创建一个管道
        int fd[2];
        int ret = pipe(fd);
    
        if(ret == -1) {
        
            perror("pipe");
            exit(0);
        }
    
        // 创建子进程
        pid_t pid = fork();
    
        if(pid > 0) {
        
            // 父进程
            // 关闭写端
            close(fd[1]);
            // 从管道中读取
            char buf[1024] = {
        0};
    
            int len = -1;
            while((len = read(fd[0], buf, sizeof(buf) - 1)) > 0) {
        
                // 过滤数据输出
                printf("%s", buf);
                memset(buf, 0, 1024);
            }
    
            wait(NULL);
    
        } else if(pid == 0) {
        
            // 子进程
            // 关闭读端
            close(fd[0]);
    
            // 文件描述符的重定向 stdout_fileno -> fd[1]
            dup2(fd[1], STDOUT_FILENO);
            // 执行 ps aux
            execlp("ps", "ps", "aux", NULL);
            perror("execlp");
            exit(0);
        } else {
        
            perror("fork");
            exit(0);
        }
        return 0;
    }

**管道的读写特点：**  
使用管道时，需要注意以下几种特殊的情况（假设都是阻塞I/O操作）  
1.所有的指向管道写端的文件描述符都关闭了（管道写端引用计数为0），有进程从管道的读端  
读数据，那么管道中剩余的数据被读取以后，再次read会返回0，就像读到文件末尾一样。

2.如果有指向管道写端的文件描述符没有关闭（管道的写端引用计数大于0），而持有管道写端的进程  
也没有往管道中写数据，这个时候有进程从管道中读取数据，那么管道中剩余的数据被读取后，  
再次read会阻塞，直到管道中有数据可以读了才读取数据并返回。

3.如果所有指向管道读端的文件描述符都关闭了（管道的读端引用计数为0），这个时候有进程  
向管道中写数据，那么该进程会收到一个信号SIGPIPE, 通常会导致进程异常终止。

4.如果有指向管道读端的文件描述符没有关闭（管道的读端引用计数大于0），而持有管道读端的进程  
也没有从管道中读数据，这时有进程向管道中写数据，那么在管道被写满的时候再次write会阻塞，  
直到管道中有空位置才能再次写入数据并返回。

**总结：**  
读管道：  
管道中有数据，read返回实际读到的字节数。  
管道中无数据：  
写端被全部关闭，read返回0（相当于读到文件的末尾）  
写端没有完全关闭，read阻塞等待

写管道：
        管道读端全部被关闭，进程异常终止（进程收到SIGPIPE信号）
        管道读端没有全部关闭：
            管道已满，write阻塞
            管道没有满，write将数据写入，并返回实际写入的字节数

案例演示：管道设置为非阻塞：

#include <unistd.h>
    #include <sys/types.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <fcntl.h>
    /*
        设置管道非阻塞
        int flags = fcntl(fd[0], F_GETFL);  // 获取原来的flag
        flags |= O_NONBLOCK;            // 修改flag的值
        fcntl(fd[0], F_SETFL, flags);   // 设置新的flag
    */
    int main() {
        
    
        // 在fork之前创建管道
        int pipefd[2];
        int ret = pipe(pipefd);
        if(ret == -1) {
        
            perror("pipe");
            exit(0);
        }
    
        // 创建子进程
        pid_t pid = fork();
        if(pid > 0) {
        
            // 父进程
            printf("i am parent process, pid : %d\n", getpid());
    
            // 关闭写端
            close(pipefd[1]);
            
            // 从管道的读取端读取数据
            char buf[1024] = {
        0};
    
            int flags = fcntl(pipefd[0], F_GETFL);  // 获取原来的flag
            flags |= O_NONBLOCK;            // 修改flag的值
            fcntl(pipefd[0], F_SETFL, flags);   // 设置新的flag
    
            while(1) {
        
                int len = read(pipefd[0], buf, sizeof(buf));
                printf("len : %d\n", len);
                printf("parent recv : %s, pid : %d\n", buf, getpid());
                memset(buf, 0, 1024);
                sleep(1);
            }
    
        } else if(pid == 0){
        
            // 子进程
            printf("i am child process, pid : %d\n", getpid());
            // 关闭读端
            close(pipefd[0]);
            char buf[1024] = {
        0};
            while(1) {
        
                // 向管道中写入数据
                char * str = "hello,i am child";
                write(pipefd[1], str, strlen(str));
                sleep(5);
            }
            
        }
        return 0;
    }

**08 / 有名管道**

◼ 匿名管道，由于没有名字，只能用于亲缘关系的进程间通信。为了克服这个缺点，提出了有名管道（FIFO），也叫命名管道、FIFO文件。  
◼ 有名管道（FIFO）不同于匿名管道之处在于它提供了一个路径名与之关联，以 FIFO 的文件形式存在于文件系统中，并且其打开方式与打开一个普通文件是一样的，这样即使与 FIFO 的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过 FIFO 相互通信，因此，通过 FIFO 不相关的进程也能交换数据。  
◼ 一旦打开了 FIFO，就能在它上面使用与操作匿名管道和其他文件的系统调用一样的I/O系统调用了（如read()、write()和close()）。与管道一样，FIFO 也有一个写入端和读取端，并且从管道中读取数据的顺序与写入的顺序是一样的。FIFO 的名称也由此而来：先入先出。

◼ 有名管道（FIFO)和匿名管道（pipe）有一些特点是相同的，**不一样的地方在于：**

1.  FIFO 在文件系统中作为一个特殊文件存在，但 FIFO 中的内容却存放在内存中。
2.  当使用 FIFO 的进程退出后，FIFO 文件将继续保存在文件系统中以便以后使用。
3.  FIFO 有名字，不相关的进程可以通过打开有名管道进行通信。

**09 / 有名管道的使用**

◼ 通过命令创建有名管道  
mkfifo 名字  
◼ 通过函数创建有名管道

#include <sys/types.h>
    #include <sys/stat.h>
    int mkfifo(const char *pathname, mode_t mode);

◼ 一旦使用 mkfifo 创建了一个 FIFO，就可以使用 open 打开它，常见的文件I/O 函数都可用于 fifo。如：close、read、write、unlink 等。

◼ FIFO 严格遵循先进先出（First in First out），对管道及 FIFO 的读总是从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如 lseek() 等文件定位操作。

有名管道的创建以及读写：  
mkfifo.c

/*
        创建fifo文件
        1.通过命令： mkfifo 名字
        2.通过函数：int mkfifo(const char *pathname, mode_t mode);
    
        #include <sys/types.h>
        #include <sys/stat.h>
        int mkfifo(const char *pathname, mode_t mode);
            参数：
                - pathname: 管道名称的路径
                - mode: 文件的权限 和 open 的 mode 是一样的
                        是一个八进制的数
            返回值：成功返回0，失败返回-1，并设置错误号
    
    */
    
    #include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    int main() {
        
    
    
        // 判断文件是否存在
        int ret = access("fifo1", F_OK);
        if(ret == -1) {
        
            printf("管道不存在，创建管道\n");
            
            ret = mkfifo("fifo1", 0664);
    
            if(ret == -1) {
        
                perror("mkfifo");
                exit(0);
            }       
    
        }
    
        
    
        return 0;
    }

read.c

#include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <fcntl.h>
    
    // 从管道中读取数据
    int main() {
        
    
        // 1.打开管道文件
        int fd = open("test", O_RDONLY);
        if(fd == -1) {
        
            perror("open");
            exit(0);
        }
    
        // 读数据
        while(1) {
        
            char buf[1024] = {
        0};
            int len = read(fd, buf, sizeof(buf));
            if(len == 0) {
        
                printf("写端断开连接了...\n");
                break;
            }
            printf("recv buf : %s\n", buf);
        }
    
        close(fd);
    
        return 0;
    }

write.c

#include <stdio.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <fcntl.h>
    #include <string.h>
    
    // 向管道中写数据
    /*
        有名管道的注意事项：
            1.一个为只读而打开一个管道的进程会阻塞，直到另外一个进程为只写打开管道
            2.一个为只写而打开一个管道的进程会阻塞，直到另外一个进程为只读打开管道
    
        读管道：
            管道中有数据，read返回实际读到的字节数
            管道中无数据：
                管道写端被全部关闭，read返回0，（相当于读到文件末尾）
                写端没有全部被关闭，read阻塞等待
        
        写管道：
            管道读端被全部关闭，进行异常终止（收到一个SIGPIPE信号）
            管道读端没有全部关闭：
                管道已经满了，write会阻塞
                管道没有满，write将数据写入，并返回实际写入的字节数。
    */
    int main() {
        
    
        // 1.判断文件是否存在
        int ret = access("test", F_OK);
        if(ret == -1) {
        
            printf("管道不存在，创建管道\n");
            
            // 2.创建管道文件
            ret = mkfifo("test", 0664);
    
            if(ret == -1) {
        
                perror("mkfifo");
                exit(0);
            }       
    
        }
    
        // 3.以只写的方式打开管道
        int fd = open("test", O_WRONLY);
        if(fd == -1) {
        
            perror("open");
            exit(0);
        }
    
        // 写数据
        for(int i = 0; i < 100; i++) {
        
            char buf[1024];
            sprintf(buf, "hello, %d\n", i);
            printf("write data : %s\n", buf);
            write(fd, buf, strlen(buf));
            sleep(1);
        }
    
        close(fd);
    
        return 0;
    }

案例：  
有名管道实现简单版聊天功能：  
chatA.c

#include <stdio.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <stdlib.h>
    #include <fcntl.h>
    #include <string.h>
    
    int main() {
        
    
        // 1.判断有名管道文件是否存在
        int ret = access("fifo1", F_OK);
        if(ret == -1) {
        
            // 文件不存在
            printf("管道不存在，创建对应的有名管道\n");
            ret = mkfifo("fifo1", 0664);
            if(ret == -1) {
        
                perror("mkfifo");
                exit(0);
            }
        }
    
        ret = access("fifo2", F_OK);
        if(ret == -1) {
        
            // 文件不存在
            printf("管道不存在，创建对应的有名管道\n");
            ret = mkfifo("fifo2", 0664);
            if(ret == -1) {
        
                perror("mkfifo");
                exit(0);
            }
        }
    
        // 2.以只写的方式打开管道fifo1
        int fdw = open("fifo1", O_WRONLY);
        if(fdw == -1) {
        
            perror("open");
            exit(0);
        }
        printf("打开管道fifo1成功，等待写入...\n");
        // 3.以只读的方式打开管道fifo2
        int fdr = open("fifo2", O_RDONLY);
        if(fdr == -1) {
        
            perror("open");
            exit(0);
        }
        printf("打开管道fifo2成功，等待读取...\n");
    
        char buf[128];
    
        // 4.循环的写读数据
        while(1) {
        
            memset(buf, 0, 128);
            // 获取标准输入的数据
            fgets(buf, 128, stdin);
            // 写数据
            ret = write(fdw, buf, strlen(buf));
            if(ret == -1) {
        
                perror("write");
                exit(0);
            }
    
            // 5.读管道数据
            memset(buf, 0, 128);
            ret = read(fdr, buf, 128);
            if(ret <= 0) {
        
                perror("read");
                break;
            }
            printf("buf: %s\n", buf);
        }
    
        // 6.关闭文件描述符
        close(fdr);
        close(fdw);
    
        return 0;
    }

chatB.c

#include <stdio.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <stdlib.h>
    #include <fcntl.h>
    #include <string.h>
    
    int main() {
        
    
        // 1.判断有名管道文件是否存在
        int ret = access("fifo1", F_OK);
        if(ret == -1) {
        
            // 文件不存在
            printf("管道不存在，创建对应的有名管道\n");
            ret = mkfifo("fifo1", 0664);
            if(ret == -1) {
        
                perror("mkfifo");
                exit(0);
            }
        }
    
        ret = access("fifo2", F_OK);
        if(ret == -1) {
        
            // 文件不存在
            printf("管道不存在，创建对应的有名管道\n");
            ret = mkfifo("fifo2", 0664);
            if(ret == -1) {
        
                perror("mkfifo");
                exit(0);
            }
        }
    
        // 2.以只读的方式打开管道fifo1
        int fdr = open("fifo1", O_RDONLY);
        if(fdr == -1) {
        
            perror("open");
            exit(0);
        }
        printf("打开管道fifo1成功，等待读取...\n");
        // 3.以只写的方式打开管道fifo2
        int fdw = open("fifo2", O_WRONLY);
        if(fdw == -1) {
        
            perror("open");
            exit(0);
        }
        printf("打开管道fifo2成功，等待写入...\n");
    
        char buf[128];
    
        // 4.循环的读写数据
        while(1) {
        
            // 5.读管道数据
            memset(buf, 0, 128);
            ret = read(fdr, buf, 128);
            if(ret <= 0) {
        
                perror("read");
                break;
            }
            printf("buf: %s\n", buf);
    
            memset(buf, 0, 128);
            // 获取标准输入的数据
            fgets(buf, 128, stdin);
            // 写数据
            ret = write(fdw, buf, strlen(buf));
            if(ret == -1) {
        
                perror("write");
                exit(0);
            }
        }
    
        // 6.关闭文件描述符
        close(fdr);
        close(fdw);
    
        return 0;
    }

**10 / 内存映射**

◼ 内存映射（Memory-mapped I/O）是将磁盘文件的数据映射到内存，用户通过修改内存就能修改磁盘文件。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 13]  
**11 / 内存映射相关系统调用**

◼ \#include <sys/mman.h>  
◼ void \*mmap(void \*addr, size\_t length, int prot, int flags,  
int fd, off\_t offset);  
◼ int munmap(void \*addr, size\_t length);

代码演示：

/*
        #include <sys/mman.h>
        void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);
            - 功能：将一个文件或者设备的数据映射到内存中
            - 参数：
                - void *addr: NULL, 由内核指定
                - length : 要映射的数据的长度，这个值不能为0。建议使用文件的长度。
                        获取文件的长度：stat lseek
                - prot : 对申请的内存映射区的操作权限
                    -PROT_EXEC ：可执行的权限
                    -PROT_READ ：读权限
                    -PROT_WRITE ：写权限
                    -PROT_NONE ：没有权限
                    要操作映射内存，必须要有读的权限。
                    PROT_READ、PROT_READ|PROT_WRITE
                - flags :
                    - MAP_SHARED : 映射区的数据会自动和磁盘文件进行同步，进程间通信，必须要设置这个选项
                    - MAP_PRIVATE ：不同步，内存映射区的数据改变了，对原来的文件不会修改，会重新创建一个新的文件。（copy on write）
                - fd: 需要映射的那个文件的文件描述符
                    - 通过open得到，open的是一个磁盘文件
                    - 注意：文件的大小不能为0，open指定的权限不能和prot参数有冲突。
                        prot: PROT_READ                open:只读/读写 
                        prot: PROT_READ | PROT_WRITE   open:读写
                - offset：偏移量，一般不用。必须指定的是4k的整数倍，0表示不便宜。
            - 返回值：返回创建的内存的首地址
                失败返回MAP_FAILED，(void *) -1
    
        int munmap(void *addr, size_t length);
            - 功能：释放内存映射
            - 参数：
                - addr : 要释放的内存的首地址
                - length : 要释放的内存的大小，要和mmap函数中的length参数的值一样。
    */
    
    /*
        使用内存映射实现进程间通信：
        1.有关系的进程（父子进程）
            - 还没有子进程的时候
                - 通过唯一的父进程，先创建内存映射区
            - 有了内存映射区以后，创建子进程
            - 父子进程共享创建的内存映射区
        
        2.没有关系的进程间通信
            - 准备一个大小不是0的磁盘文件
            - 进程1 通过磁盘文件创建内存映射区
                - 得到一个操作这块内存的指针
            - 进程2 通过磁盘文件创建内存映射区
                - 得到一个操作这块内存的指针
            - 使用内存映射区通信
    
        注意：内存映射区通信，是非阻塞。
    */
    
    #include <stdio.h>
    #include <sys/mman.h>
    #include <fcntl.h>
    #include <sys/types.h>
    #include <unistd.h>
    #include <string.h>
    #include <stdlib.h>
    #include <wait.h>
    
    // 作业:使用内存映射实现没有关系的进程间的通信。
    int main() {
        
    
        // 1.打开一个文件
        int fd = open("test.txt", O_RDWR);
        int size = lseek(fd, 0, SEEK_END);  // 获取文件的大小
    
        // 2.创建内存映射区
        void *ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
        if(ptr == MAP_FAILED) {
        
            perror("mmap");
            exit(0);
        }
    
        // 3.创建子进程
        pid_t pid = fork();
        if(pid > 0) {
        
            wait(NULL);
            // 父进程
            char buf[64];
            strcpy(buf, (char *)ptr);
            printf("read data : %s\n", buf);
           
        }else if(pid == 0){
        
            // 子进程
            strcpy((char *)ptr, "nihao a, son!!!");
        }
    
        // 关闭内存映射区
        munmap(ptr, size);
    
        return 0;
    }

**12 / 思考问题**

◼ 如果对mmap的返回值(ptr)做++操作(ptr++), munmap是否能够成功?  
◼ 如果open时O\_RDONLY, mmap时prot参数指定PROT\_READ | PROT\_WRITE会怎样?  
◼ 如果文件偏移量为1000会怎样?  
◼ mmap什么情况下会调用失败?  
◼ 可以open的时候O\_CREAT一个新文件来创建映射区吗?  
◼ mmap后关闭文件描述符，对mmap映射有没有影响？  
◼ 对ptr越界操作会怎样？

**解答：**  
1.如果对mmap的返回值(ptr)做++操作(ptr++), munmap是否能够成功?  
void \* ptr = mmap(…);  
ptr++; 可以对其进行++操作  
munmap(ptr, len); // 错误,要保存地址

2.如果open时O\_RDONLY, mmap时prot参数指定PROT\_READ | PROT\_WRITE会怎样?  
错误，返回MAP\_FAILED  
open()函数中的权限建议和prot参数的权限保持一致。

3.如果文件偏移量为1000会怎样?  
偏移量必须是4K的整数倍，返回MAP\_FAILED

4.mmap什么情况下会调用失败?  
\- 第二个参数：length = 0  
\- 第三个参数：prot  
\- 只指定了写权限  
\- prot PROT\_READ | PROT\_WRITE  
第5个参数fd 通过open函数时指定的 O\_RDONLY / O\_WRONLY

5.可以open的时候O\_CREAT一个新文件来创建映射区吗?  
\- 可以的，但是创建的文件的大小如果为0的话，肯定不行  
\- 可以对新的文件进行扩展  
\- lseek()  
\- truncate()

6.mmap后关闭文件描述符，对mmap映射有没有影响？  
int fd = open(“XXX”);  
mmap(,fd,0);  
close(fd);  
映射区还存在，创建映射区的fd被关闭，没有任何影响。

7.对ptr越界操作会怎样？  
void \* ptr = mmap(NULL, 100,);  
4K  
越界操作操作的是非法的内存 -> 段错误

代码演示：通过映射来进行文件拷贝：

// 使用内存映射实现文件拷贝的功能
    /*
        思路：
            1.对原始的文件进行内存映射
            2.创建一个新文件（拓展该文件）
            3.把新文件的数据映射到内存中
            4.通过内存拷贝将第一个文件的内存数据拷贝到新的文件内存中
            5.释放资源
    */
    #include <stdio.h>
    #include <sys/mman.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <string.h>
    #include <stdlib.h>
    
    int main() {
        
    
        // 1.对原始的文件进行内存映射
        int fd = open("english.txt", O_RDWR);
        if(fd == -1) {
        
            perror("open");
            exit(0);
        }
    
        // 获取原始文件的大小
        int len = lseek(fd, 0, SEEK_END);
    
        // 2.创建一个新文件（拓展该文件）
        int fd1 = open("cpy.txt", O_RDWR | O_CREAT, 0664);
        if(fd1 == -1) {
        
            perror("open");
            exit(0);
        }
        
        // 对新创建的文件进行拓展
        truncate("cpy.txt", len);
        write(fd1, " ", 1);
    
        // 3.分别做内存映射
        void * ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
        void * ptr1 = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd1, 0);
    
        if(ptr == MAP_FAILED) {
        
            perror("mmap");
            exit(0);
        }
    
        if(ptr1 == MAP_FAILED) {
        
            perror("mmap");
            exit(0);
        }
    
        // 内存拷贝
        memcpy(ptr1, ptr, len);
        
        // 释放资源
        munmap(ptr1, len);
        munmap(ptr, len);
    
        close(fd1);
        close(fd);
    
        return 0;
    }

匿名映射：

/*
        匿名映射：不需要文件实体进程一个内存映射
    */
    
    #include <stdio.h>
    #include <sys/mman.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <string.h>
    #include <stdlib.h>
    #include <sys/wait.h>
    
    int main() {
        
    
        // 1.创建匿名内存映射区
        int len = 4096;
        void * ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
        if(ptr == MAP_FAILED) {
        
            perror("mmap");
            exit(0);
        }
    
        // 父子进程间通信
        pid_t pid = fork();
    
        if(pid > 0) {
        
            // 父进程
            strcpy((char *) ptr, "hello, world");
            wait(NULL);
        }else if(pid == 0) {
        
            // 子进程
            sleep(1);
            printf("%s\n", (char *)ptr);
        }
    
        // 释放内存映射区
        int ret = munmap(ptr, len);
    
        if(ret == -1) {
        
            perror("munmap");
            exit(0);
        }
        return 0;
    }

**7：信号**

**01 / 信号的概念**

◼ 信号是 Linux 进程间通信的最古老的方式之一，是事件发生时对进程的通知机制，有时也称之为软件中断，它是在软件层次上对中断机制的一种模拟，是一种异步通信的方式。信号可以导致一个正在运行的进程被另一个正在运行的异步进程中断，转而处理某一个突发事件。

◼ 发往进程的诸多信号，通常都是源于内核。引发内核为进程产生信号的各类事件如下：  
 对于前台进程，用户可以通过输入特殊的终端字符来给它发送信号。比如输入Ctrl+C 通常会给进程发送一个中断信号。  
 硬件发生异常，即硬件检测到一个错误条件并通知内核，随即再由内核发送相应信号给相关进程。比如执行一条异常的机器语言指令，诸如被 0 除，或者引用了无法访问的内存区域。  
 系统状态变化，比如 alarm 定时器到期将引起 SIGALRM 信号，进程执行的 CPU 时间超限，或者该进程的某个子进程退出。  
 运行 kill 命令或调用 kill 函数。

◼ 使用信号的两个主要目的是：  
 让进程知道已经发生了一个特定的事情。  
 强迫进程执行它自己代码中的信号处理程序。

◼ 信号的特点：  
 简单  
 不能携带大量信息  
 满足某个特定条件才发送  
 优先级比较高

◼ 查看系统定义的信号列表：kill –l  
◼ 前 31 个信号为常规信号，其余为实时信号。

**02 / Linux 信号一览表**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 14]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 15]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 16]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 17]  
**03 / 信号的 5 种默认处理动作**

◼ 查看信号的详细信息：man 7 signal  
◼ 信号的 5 中默认处理动作  
 Term 终止进程  
 Ign 当前进程忽略掉这个信号  
 Core 终止进程，并生成一个Core文件  
 Stop 暂停当前进程  
 Cont 继续执行当前被暂停的进程  
◼ 信号的几种状态：产生、未决、递达  
◼ SIGKILL 和 SIGSTOP 信号不能被捕捉、阻塞或者忽略，只能执行默认动作。

**04 / 信号相关的函数**

◼ int kill(pid_t pid, int sig);
    ◼ int raise(int sig);
    ◼ void abort(void);

参考代码：

/*  
        #include <sys/types.h>
        #include <signal.h>
    
        int kill(pid_t pid, int sig);
            - 功能：给任何的进程或者进程组pid, 发送任何的信号 sig
            - 参数：
                - pid ：
                    > 0 : 将信号发送给指定的进程
                    = 0 : 将信号发送给当前的进程组
                    = -1 : 将信号发送给每一个有权限接收这个信号的进程
                    < -1 : 这个pid=某个进程组的ID取反 （-12345）
                - sig : 需要发送的信号的编号或者是宏值，0表示不发送任何信号
    
            kill(getppid(), 9);
            kill(getpid(), 9);
            
        int raise(int sig);
            - 功能：给当前进程发送信号
            - 参数：
                - sig : 要发送的信号
            - 返回值：
                - 成功 0
                - 失败 非0
            kill(getpid(), sig);   
    
        void abort(void);
            - 功能： 发送SIGABRT信号给当前的进程，杀死当前进程
            kill(getpid(), SIGABRT);
    */
    
    #include <stdio.h>
    #include <sys/types.h>
    #include <signal.h>
    #include <unistd.h>
    
    int main() {
        
    
        pid_t pid = fork();
    
        if(pid == 0) {
        
            // 子进程
            int i = 0;
            for(i = 0; i < 5; i++) {
        
                printf("child process\n");
                sleep(1);
            }
    
        } else if(pid > 0) {
        
            // 父进程
            printf("parent process\n");
            sleep(2);
            printf("kill child process now\n");
            kill(pid, SIGINT);
        }
    
        return 0;
    }

◼ unsigned int alarm(unsigned int seconds);

代码演示：

/*
        #include <unistd.h>
        unsigned int alarm(unsigned int seconds);
            - 功能：设置定时器（闹钟）。函数调用，开始倒计时，当倒计时为0的时候，
                    函数会给当前的进程发送一个信号：SIGALARM
            - 参数：
                seconds: 倒计时的时长，单位：秒。如果参数为0，定时器无效（不进行倒计时，不发信号）。
                        取消一个定时器，通过alarm(0)。
            - 返回值：
                - 之前没有定时器，返回0
                - 之前有定时器，返回之前的定时器剩余的时间
    
        - SIGALARM ：默认终止当前的进程，每一个进程都有且只有唯一的一个定时器。
            alarm(10);  -> 返回0
            过了1秒
            alarm(5);   -> 返回9
    
        alarm(100) -> 该函数是不阻塞的
    */
    
    #include <stdio.h>
    #include <unistd.h>
    
    int main() {
        
    
        int seconds = alarm(5);
        printf("seconds = %d\n", seconds);  // 0
    
        sleep(2);
        seconds = alarm(2);    // 不阻塞
        printf("seconds = %d\n", seconds);  // 3
    
        while(1) {
        
        }
    
        return 0;
    }

案例：1秒钟电脑能数多少个数？

// 1秒钟电脑能数多少个数？
    #include <stdio.h>
    #include <unistd.h>
    
    /*
        实际的时间 = 内核时间 + 用户时间 + 消耗的时间
        进行文件IO操作的时候比较浪费时间
    
        定时器，与进程的状态无关（自然定时法）。无论进程处于什么状态，alarm都会计时。
    */
    
    int main() {
            
    
        alarm(1);
    
        int i = 0;
        while(1) {
        
            printf("%i\n", i++);
        }
    
        return 0;
    }

◼ int setitimer(int which, const struct itimerval \*new\_val,  
struct itimerval \*old\_value);

代码演示：

/*
        #include <sys/time.h>
        int setitimer(int which, const struct itimerval *new_value,
                            struct itimerval *old_value);
        
            - 功能：设置定时器（闹钟）。可以替代alarm函数。精度微妙us，可以实现周期性定时
            - 参数：
                - which : 定时器以什么时间计时
                  ITIMER_REAL: 真实时间，时间到达，发送 SIGALRM   常用
                  ITIMER_VIRTUAL: 用户时间，时间到达，发送 SIGVTALRM
                  ITIMER_PROF: 以该进程在用户态和内核态下所消耗的时间来计算，时间到达，发送 SIGPROF
    
                - new_value: 设置定时器的属性
                
                    struct itimerval {      // 定时器的结构体
                    struct timeval it_interval;  // 每个阶段的时间，间隔时间
                    struct timeval it_value;     // 延迟多长时间执行定时器
                    };
    
                    struct timeval {        // 时间的结构体
                        time_t      tv_sec;     //  秒数     
                        suseconds_t tv_usec;    //  微秒    
                    };
    
                过10秒后，每个2秒定时一次
               
                - old_value ：记录上一次的定时的时间参数，一般不使用，指定NULL
            
            - 返回值：
                成功 0
                失败 -1 并设置错误号
    */
    
    #include <sys/time.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    // 过3秒以后，每隔2秒钟定时一次
    int main() {
        
    
        struct itimerval new_value;
    
        // 设置间隔的时间
        new_value.it_interval.tv_sec = 2;
        new_value.it_interval.tv_usec = 0;
    
        // 设置延迟的时间,3秒之后开始第一次定时
        new_value.it_value.tv_sec = 3;
        new_value.it_value.tv_usec = 0;
    
    
        int ret = setitimer(ITIMER_REAL, &new_value, NULL); // 非阻塞的
        printf("定时器开始了...\n");
    
        if(ret == -1) {
        
            perror("setitimer");
            exit(0);
        }
    
        getchar();
    
        return 0;
    }

◼ sighandler\_t signal(int signum, sighandler\_t handler);

/*
        #include <signal.h>
        typedef void (*sighandler_t)(int);
        sighandler_t signal(int signum, sighandler_t handler);
            - 功能：设置某个信号的捕捉行为
            - 参数：
                - signum: 要捕捉的信号
                - handler: 捕捉到信号要如何处理
                    - SIG_IGN ： 忽略信号
                    - SIG_DFL ： 使用信号默认的行为
                    - 回调函数 :  这个函数是内核调用，程序员只负责写，捕捉到信号后如何去处理信号。
                    回调函数：
                        - 需要程序员实现，提前准备好的，函数的类型根据实际需求，看函数指针的定义
                        - 不是程序员调用，而是当信号产生，由内核调用
                        - 函数指针是实现回调的手段，函数实现之后，将函数名放到函数指针的位置就可以了。
    
            - 返回值：
                成功，返回上一次注册的信号处理函数的地址。第一次调用返回NULL
                失败，返回SIG_ERR，设置错误号
                
        SIGKILL SIGSTOP不能被捕捉，不能被忽略。
    */
    
    #include <sys/time.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <signal.h>
    
    void myalarm(int num) {
        
        printf("捕捉到了信号的编号是：%d\n", num);
        printf("xxxxxxx\n");
    }
    
    // 过3秒以后，每隔2秒钟定时一次
    int main() {
        
    
        // 注册信号捕捉
        // signal(SIGALRM, SIG_IGN);
        // signal(SIGALRM, SIG_DFL);
        // void (*sighandler_t)(int); 函数指针，int类型的参数表示捕捉到的信号的值。
        signal(SIGALRM, myalarm);
    
        struct itimerval new_value;
    
        // 设置间隔的时间
        new_value.it_interval.tv_sec = 2;
        new_value.it_interval.tv_usec = 0;
    
        // 设置延迟的时间,3秒之后开始第一次定时
        new_value.it_value.tv_sec = 3;
        new_value.it_value.tv_usec = 0;
    
        int ret = setitimer(ITIMER_REAL, &new_value, NULL); // 非阻塞的
        printf("定时器开始了...\n");
    
        if(ret == -1) {
        
            perror("setitimer");
            exit(0);
        }
    
        getchar();
    
        return 0;
    }

**06 / 信号集**

◼ 许多信号相关的系统调用都需要能表示一组不同的信号，多个信号可使用一个称之为信号集的数据结构来表示，其系统数据类型为 sigset\_t。 ◼ 在 PCB 中有两个非常重要的信号集。一个称之为 “阻塞信号集” ，另一个称之为“未决信号集” 。这两个信号集都是内核使用位图机制来实现的。但操作系统不允许我们直接对这两个信号集进行位操作。而需自定义另外一个集合，借助信号集操作函数来对 PCB 中的这两个信号集进行修改。  
◼ 信号的 “未决” 是一种状态，指的是从信号的产生到信号被处理前的这一段时间。  
◼ 信号的 “阻塞” 是一个开关动作，指的是阻止信号被处理，但不是阻止信号产生。  
◼ 信号的阻塞就是让系统暂时保留信号留待以后发送。由于另外有办法让系统忽略信号，所以一般情况下信号的阻塞只是暂时的，只是为了防止信号打断敏感的操作。

**07 / 阻塞信号集和未决信号集**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 18]  
**08 / 信号集相关的函数**

◼ int sigemptyset(sigset\_t \*set);  
◼ int sigfillset(sigset\_t \*set);  
◼ int sigaddset(sigset\_t \*set, int signum);  
◼ int sigdelset(sigset\_t \*set, int signum);  
◼ int sigismember(const sigset\_t \*set, int signum);

/*
        以下信号集相关的函数都是对自定义的信号集进行操作。
    
        int sigemptyset(sigset_t *set);
            - 功能：清空信号集中的数据,将信号集中的所有的标志位置为0
            - 参数：set,传出参数，需要操作的信号集
            - 返回值：成功返回0， 失败返回-1
    
        int sigfillset(sigset_t *set);
            - 功能：将信号集中的所有的标志位置为1
            - 参数：set,传出参数，需要操作的信号集
            - 返回值：成功返回0， 失败返回-1
    
        int sigaddset(sigset_t *set, int signum);
            - 功能：设置信号集中的某一个信号对应的标志位为1，表示阻塞这个信号
            - 参数：
                - set：传出参数，需要操作的信号集
                - signum：需要设置阻塞的那个信号
            - 返回值：成功返回0， 失败返回-1
    
        int sigdelset(sigset_t *set, int signum);
            - 功能：设置信号集中的某一个信号对应的标志位为0，表示不阻塞这个信号
            - 参数：
                - set：传出参数，需要操作的信号集
                - signum：需要设置不阻塞的那个信号
            - 返回值：成功返回0， 失败返回-1
    
        int sigismember(const sigset_t *set, int signum);
            - 功能：判断某个信号是否阻塞
            - 参数：
                - set：需要操作的信号集
                - signum：需要判断的那个信号
            - 返回值：
                1 ： signum被阻塞
                0 ： signum不阻塞
                -1 ： 失败
    
    */
    
    #include <signal.h>
    #include <stdio.h>
    
    int main() {
        
    
        // 创建一个信号集
        sigset_t set;
    
        // 清空信号集的内容
        sigemptyset(&set);
    
        // 判断 SIGINT 是否在信号集 set 里
        int ret = sigismember(&set, SIGINT);
        if(ret == 0) {
        
            printf("SIGINT 不阻塞\n");
        } else if(ret == 1) {
        
            printf("SIGINT 阻塞\n");
        }
    
        // 添加几个信号到信号集中
        sigaddset(&set, SIGINT);
        sigaddset(&set, SIGQUIT);
    
        // 判断SIGINT是否在信号集中
        ret = sigismember(&set, SIGINT);
        if(ret == 0) {
        
            printf("SIGINT 不阻塞\n");
        } else if(ret == 1) {
        
            printf("SIGINT 阻塞\n");
        }
    
        // 判断SIGQUIT是否在信号集中
        ret = sigismember(&set, SIGQUIT);
        if(ret == 0) {
        
            printf("SIGQUIT 不阻塞\n");
        } else if(ret == 1) {
        
            printf("SIGQUIT 阻塞\n");
        }
    
        // 从信号集中删除一个信号
        sigdelset(&set, SIGQUIT);
    
        // 判断SIGQUIT是否在信号集中
        ret = sigismember(&set, SIGQUIT);
        if(ret == 0) {
        
            printf("SIGQUIT 不阻塞\n");
        } else if(ret == 1) {
        
            printf("SIGQUIT 阻塞\n");
        }
    
        return 0;
    }

1.用户通过键盘 Ctrl + C, 产生2号信号SIGINT (信号被创建)

2.信号产生但是没有被处理 （未决）  
\- 在内核中将所有的没有被处理的信号存储在一个集合中 （未决信号集）  
\- SIGINT信号状态被存储在第二个标志位上  
\- 这个标志位的值为0， 说明信号不是未决状态  
\- 这个标志位的值为1， 说明信号处于未决状态

3.这个未决状态的信号，需要被处理，处理之前需要和另一个信号集（阻塞信号集），进行比较  
\- 阻塞信号集默认不阻塞任何的信号  
\- 如果想要阻塞某些信号需要用户调用系统的API

4.在处理的时候和阻塞信号集中的标志位进行查询，看是不是对该信号设置阻塞了  
\- 如果没有阻塞，这个信号就被处理  
\- 如果阻塞了，这个信号就继续处于未决状态，直到阻塞解除，这个信号就被处理

◼ int sigprocmask(int how, const sigset\_t \*set, sigset\_t \*oldset);  
◼ int sigpending(sigset\_t \*set);

/*
        int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
            - 功能：将自定义信号集中的数据设置到内核中（设置阻塞，解除阻塞，替换）
            - 参数：
                - how : 如何对内核阻塞信号集进行处理
                    SIG_BLOCK: 将用户设置的阻塞信号集添加到内核中，内核中原来的数据不变
                        假设内核中默认的阻塞信号集是mask， mask | set
                    SIG_UNBLOCK: 根据用户设置的数据，对内核中的数据进行解除阻塞
                        mask &= ~set
                    SIG_SETMASK:覆盖内核中原来的值
                
                - set ：已经初始化好的用户自定义的信号集
                - oldset : 保存设置之前的内核中的阻塞信号集的状态，可以是 NULL
            - 返回值：
                成功：0
                失败：-1
                    设置错误号：EFAULT、EINVAL
    
        int sigpending(sigset_t *set);
            - 功能：获取内核中的未决信号集
            - 参数：set,传出参数，保存的是内核中的未决信号集中的信息。
    */
    
    // 编写一个程序，把所有的常规信号（1-31）的未决状态打印到屏幕
    // 设置某些信号是阻塞的，通过键盘产生这些信号
    
    #include <stdio.h>
    #include <signal.h>
    #include <stdlib.h>
    #include <unistd.h>
    
    int main() {
        
    
        // 设置2、3号信号阻塞
        sigset_t set;
        sigemptyset(&set);
        // 将2号和3号信号添加到信号集中
        sigaddset(&set, SIGINT);
        sigaddset(&set, SIGQUIT);
    
        // 修改内核中的阻塞信号集
        sigprocmask(SIG_BLOCK, &set, NULL);
    
        int num = 0;
    
        while(1) {
        
            num++;
            // 获取当前的未决信号集的数据
            sigset_t pendingset;
            sigemptyset(&pendingset);
            sigpending(&pendingset);
    
            // 遍历前32位
            for(int i = 1; i <= 31; i++) {
        
                if(sigismember(&pendingset, i) == 1) {
        
                    printf("1");
                }else if(sigismember(&pendingset, i) == 0) {
        
                    printf("0");
                }else {
        
                    perror("sigismember");
                    exit(0);
                }
            }
    
            printf("\n");
            sleep(1);
            if(num == 10) {
        
                // 解除阻塞
                sigprocmask(SIG_UNBLOCK, &set, NULL);
            }
    
        }
    
    
        return 0;
    }

**09 / 内核实现信号捕捉的过程**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 19]  
◼ int sigaction(int signum, const struct sigaction \*act,  
struct sigaction \*oldact);

/*
        #include <signal.h>
        int sigaction(int signum, const struct sigaction *act,
                                struct sigaction *oldact);
    
            - 功能：检查或者改变信号的处理。信号捕捉
            - 参数：
                - signum : 需要捕捉的信号的编号或者宏值（信号的名称）
                - act ：捕捉到信号之后的处理动作
                - oldact : 上一次对信号捕捉相关的设置，一般不使用，传递NULL
            - 返回值：
                成功 0
                失败 -1
    
         struct sigaction {
            // 函数指针，指向的函数就是信号捕捉到之后的处理函数
            void     (*sa_handler)(int);
            // 不常用
            void     (*sa_sigaction)(int, siginfo_t *, void *);
            // 临时阻塞信号集，在信号捕捉函数执行过程中，临时阻塞某些信号。
            sigset_t   sa_mask;
            // 使用哪一个信号处理对捕捉到的信号进行处理
            // 这个值可以是0，表示使用sa_handler,也可以是SA_SIGINFO表示使用sa_sigaction
            int        sa_flags;
            // 被废弃掉了
            void     (*sa_restorer)(void);
        };
    
    */
    #include <sys/time.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <signal.h>
    
    void myalarm(int num) {
        
        printf("捕捉到了信号的编号是：%d\n", num);
        printf("xxxxxxx\n");
    }
    
    // 过3秒以后，每隔2秒钟定时一次
    int main() {
        
    
        struct sigaction act;
        act.sa_flags = 0;
        act.sa_handler = myalarm;
        sigemptyset(&act.sa_mask);  // 清空临时阻塞信号集
       
        // 注册信号捕捉
        sigaction(SIGALRM, &act, NULL);
    
        struct itimerval new_value;
    
        // 设置间隔的时间
        new_value.it_interval.tv_sec = 2;
        new_value.it_interval.tv_usec = 0;
    
        // 设置延迟的时间,3秒之后开始第一次定时
        new_value.it_value.tv_sec = 3;
        new_value.it_value.tv_usec = 0;
    
        int ret = setitimer(ITIMER_REAL, &new_value, NULL); // 非阻塞的
        printf("定时器开始了...\n");
    
        if(ret == -1) {
        
            perror("setitimer");
            exit(0);
        }
    
        // getchar();
        while(1);
    
        return 0;
    }

**10 / SIGCHLD信号**

◼ SIGCHLD信号产生的条件  
 子进程终止时  
 子进程接收到 SIGSTOP 信号停止时  
 子进程处在停止态，接受到SIGCONT后唤醒时

◼ 以上三种条件都会给父进程发送 SIGCHLD 信号，父进程默认会忽略该信号

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70]: /images/20221022/452814b3570347099b1e09a9e24124e5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210319160251885.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2021031916502314.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210319165050943.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210319173649751.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/2021031917545874.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/2021032213080045.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20210322141956336.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20210322163215177.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20210322163420400.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20210322163614690.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/2021032301053692.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20210323010706104.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20210323120203605.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 14]: https://img-blog.csdnimg.cn/20210323183530414.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 15]: https://img-blog.csdnimg.cn/20210323183550876.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 16]: https://img-blog.csdnimg.cn/20210323183611802.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 17]: https://img-blog.csdnimg.cn/20210323183634903.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 18]: https://img-blog.csdnimg.cn/20210324182315842.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA_size_16_color_FFFFFF_t_70 19]: https://img-blog.csdnimg.cn/202103241832436.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDczNDUxNA==,size_16,color_FFFFFF,t_70