一、进程概述

1、程序和进程

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

• 二进制格式标识：每个程序文件都包含用于描述可执行文件格式的元信息。内核利用此信息来解释文件中的其他信息。（ELF可执行连接格式）
• 机器语言指令：对程序算法进行编码。
• 程序入口地址：标识程序开始执行时的起始指令位置。
• 数据：程序文件包含的变量初始值和程序使用的字面量值（比如字符串）。
• 符号表及重定位表：描述程序中函数和变量的位置及名称。这些表格有多重用途，其中包括调试和运行时的符号解析（动态链接）。
• 共享库和动态链接信息：程序文件所包含的一些字段，列出了程序运行时需要使用的共享库，以及加载共享库的动态连接器的路径名。
• 其他信息：程序文件还包含许多其他信息，用以描述如何创建进程。
• 进程是正在运行的程序的实例。是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。
• 可以用一个程序来创建多个进程，进程是由内核定义的抽象实体，并为该实体分配用以执行程序的各项系统资源。从内核的角度看，进程由用户内存空间和一系列内核数据结构组成，其中用户内存空间包含了程序代码及代码所使用的变量，而内核数据结构则用于维护进程状态信息。记录在内核数据结构中的信息包括许多与进程相关的标识号（IDs）、虚拟内存表、打开文件的描述符表、信号传递及处理的有关信息、进程资源使用及限制、当前工作目录和大量的其他信息。

2、单道、多道程序设计

• 单道程序，即在计算机内存中只允许一个的程序运行。
• 多道程序设计技术是在计算机内存中同时存放几道相互独立的程序，使它们在管理程序控制下，相互穿插运行，两个或两个以上程序在计算机系统中同处于开始到结束之间的状态, 这些程序共享计算机系统资源。引入多道程序设计技术的根本目的是为了提高 CPU 的利用率。
• 对于一个单 CPU 系统来说，程序同时处于运行状态只是一种宏观上的概念，他们虽然都已经开始运行，但就微观而言，任意时刻，CPU 上运行的程序只有一个。
• 在多道程序设计模型中，多个进程轮流使用 CPU。而当下常见 CPU 为纳秒级，1秒可以执行大约 10 亿条指令。由于人眼的反应速度是毫秒级，所以看似同时在运行。

3、时间片

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

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

4、并行和并发

并行(parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。

并发(concurrency)：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。

并发是两个队列交替使用一台咖啡机。

并行是两个队列同时使用两台咖啡机。

5、进程控制块（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）

// 列出进程使用的资源上限
ulimit -a

二、进程状态转换

1、进程的状态

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

• 新建态：进程刚被创建时的状态，尚未进入就绪队列

• 就绪态：进程具备运行条件，等待系统分配处理器以便运行。当进程已分配到除 CPU 以外的所有必要资源后，只要再获得 CPU ，便可立即执行。在一个系统中处于就绪状态的进程可能有多个，通常将它们排成一个队列，称为就绪队列

• 运行态：进程占有处理器正在运行

• 阻塞态：又称为等待（wait）态或睡眠（sleep）态，指进程不具备运行条件，正在等待某个事件的完成

• 终止态：进程完成任务到达正常结束点，或出现无法克服的错误而异常终止，或被操作系统及有终止权的进程所终止时所处的状态。进入终止态的进程以后不再执行，但依然保留在操作系统中等待善后。一旦其他进程完成了对终止态进程的信息抽取之后，操作系统将删除该进程。

2、进程相关命令

查看进程

ps aux / ajx

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

tty：查看当前终端

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 -9 xxx

kill -l ：列出所有信号

kill -SIGKILL 进程ID

kill -9 进程ID

ps aux
kill -9 pid
或者
kill -SIGKILL pid

杀死我们新建的一个终端

杀死死循环程序

我们创建一个 test.c 程序，通过gcc -o test test.c编译汇编链接成一个可执行程序。我们执行这个程序

#include<stdio.h>
#include<unistd.h>int main()
{while(1){printf("hello\n");// 休眠1ssleep(1);}return 0;
}

然后我们通过ps aux，找到这个正在运行的程序，通过kill -9 pid来杀死这个进程。

// 以后台形式来运行程序
./test &

killall 进程名：根据进程名杀死进程

3、进程号和相关函数

每个进程都由进程号来标识，其类型为 pid_t （整型），进程号的范围 0 ~ 32767 。进程号总是唯一的，但可以重用。当一个进程终止后，其进程号就可以再次使用。

任何进程（除 init 进程）都是由另一个进程创建，该进程称为被创建进程的父进程，对应的进程号称为父进程号（ PPID ）。

进程组是一个或多个进程的集合。他们之间相互关联，进程组可以接收同一终端的各种信号，关联的进程有一个进程组号（ PGID ）。默认情况下，当前的进程号会当做当前的进程组号。

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

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

三、进程创建

1、进程创建

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

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

返回值：

• 成功：子进程返回 0，父进程中返回子进程 ID
• 失败：返回 -1

失败的两个主要原因：

1. 当前系统的进程数已经达到了系统规定的上限，这是 errno 的值被设置为 EAGAIN（当一个系统调用(比如fork)因为没有足够的资源(比如虚拟内存)而执行失败，返回EAGAIN提示其再调用一次(也许下次就能成功)。）
2. 系统内存不足，这是 errno 的值被设置为 ENOMEM

/*
#include <sys/types.h>
#include <unistd.h>pid_t fork(void);作用：用于创建子进程返回值：fork()的返回值会返回两次。一次是在父进程中，一次是在子进程中。在父进程中返回创建的子进程的ID，在子进程中返回0如果区分父进程和子进程：通过fork的返回值。在父进程中返回 -1，表示创建子进程失败，并且设置 errno
*/
#include <sys/types.h>
#include <unistd.h>
#include<stdio.h>
int main()
{// 创建子进程pid_t pid = fork();printf("pid = %d\n",pid);// 判断：判断是父进程还是子进程if(pid > 0){// 如果大于0，返回的是创建的子进程的进程号，当前是父进程printf("I am parent process,pid = %d, ppid = %d\n",getpid(),getppid());}else if(pid == 0){// 当前是子进程printf("I am child process,pid = %d, ppid = %d\n",getpid(),getppid());}else {// pid < 0，表示创建子进程失败，当前是父进程printf("I am parent process2,pid = %d, ppid = %d\n",getpid(),getppid());}// for 循环for(int i = 0; i < 5; i++){printf("i = %d, pid = %d\n", i, getpid());sleep(1);// 睡眠 1 s}return 0;
}

qykhhr@qykhhr:~/Linux/lesson18$ ./fork
pid = 4148
I am parent process,pid = 4147, ppid = 4051
i = 0, pid = 4147
pid = 0
I am child process,pid = 4148, ppid = 4147
i = 0, pid = 4148
i = 1, pid = 4148
i = 1, pid = 4147
i = 2, pid = 4148
i = 2, pid = 4147
i = 3, pid = 4147
i = 3, pid = 4148
i = 4, pid = 4148
i = 4, pid = 4147

父进程的父进程是 bash（终端进程），我们可以通过ps aux来通过进程号查看进程信息。

首先父进程执行到fork时会创建子进程，fork后会给父子进程分别返回一个pid号（父进程fork后返回的pid号为子进程的pid=10089,而返回给子进程的pid号为0。注意，该代码第二行的pid是由fork创建后返回的pid，并不是该进程本身的pid，这点容易搞混，最好改一下命名如r_pid好一些），此时系统会将父进程的用户去数据和内核区拷贝过来生成一段新的虚拟地址空间供子进程使用，然后父进程开始继续执行if()判断，此时子进程是在父进程fork()后创造出来的，因此子进程只会执行fork()之后的语句，即也进行if()判断。但不同的是父进程是通过栈空间返回的pid号为大于0的值，而子进程通过栈空间返回的pid号为等于0的值。因此父子进程执行的if条件语句并不相同。

（实际更精准的说，Linux的fork()函数是通过写时拷贝来实现的，即fork后内核实际并不复制整个父进程的地址空间，而是让父子进程以只读的方式共享一个地址空间，只有在写入操作时才会进行资源的复制操作）

2、父子进程虚拟地址空间

程序在 fork 之后

定义一个局部变量 num，在父子进程中分别操作这个变量

/*
#include <sys/types.h>
#include <unistd.h>pid_t fork(void);作用：用于创建子进程返回值：fork()的返回值会返回两次。一次是在父进程中，一次是在子进程中。在父进程中返回创建的子进程的ID，在子进程中返回0如果区分父进程和子进程：通过fork的返回值。在父进程中返回 -1，表示创建子进程失败，并且设置 errno
*/
#include <sys/types.h>
#include <unistd.h>
#include<stdio.h>
int main()
{int num = 10;// 创建子进程pid_t pid = fork();printf("pid = %d\n",pid);// 判断：判断是父进程还是子进程if(pid > 0){// 如果大于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 += 10 = %d\n",num);}else {// pid < 0，表示创建子进程失败，当前是父进程printf("I am parent process2,pid = %d, ppid = %d\n",getpid(),getppid());}return 0; 
}

pid = 4051
I am parent process,pid = 4050, ppid = 3782
parent num = 10
parent num += 10 = 20
pid = 0
I am child process,pid = 4051, ppid = 4050
child num = 10
child num += 10 = 110

可以看到父子进程分别操作各自的 num 变量，互相不会影响。

读时共享、写时拷贝

实际上，更准确来说，Linux 的 fork() 使用是通过写时拷贝（copy-on-write）实现。写时拷贝是一种可以推迟甚至避免拷贝数据的技术。子进程创建出来后，内核此时并不复制整个进程的地址空间，而是让父子进程共享同一个地址空间。只用在需要写入的时候才会复制地址空间，从而使各个进程拥有自己的地址空间。也就是说，资源的复制只有在写入的时候才会进行，在此之前，只有以只读方式共享。

注意：fork之后父子进程共享文件，fork 产生的子进程与父进程相同的文件描述符指向相同的文件表，引用计数增加，共享文件偏移指针。

父子进程之间的关系：

区别：

1、fork() 函数返回值不同
父进程中：> 0 返回的子进程的ID
子进程中：= 0
2、pcb 中的一些数据
当前的进程id pid
当前的进程的父进程的id ppid
信号集

共同点：

某些状态下：子进程刚被创建出来，还没有执行任何的写数据的操作

• 用户区的数据
• 文件描述符表

父子进程对变量是不是共享的？

• 刚开始的时候是一样的，共享的。如果修改了数据，不共享了。
• 读时共享（子进程刚被创建，两个进程没有做任何写的操作），写时拷贝

因为父子进程中变量是不能共享的，所以我们不能变量进行通信

3、GDB 多进程调试

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

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

我们可以使用show follow-fork-mode 来查看当前调试的默认进程：

(gdb) show follow-fork-mode
Debugger response to a program call of fork or vfork is "parent".

设置调试父进程或者子进程：set follow-fork-mode [parent(默认) | child]

(gdb) set follow-fork-mode child
(gdb) show follow-fork-mode
Debugger response to a program call of fork or vfork is "child".

设置调试模式：set detach-on-fork [on | off] 8.x版本GDB调试失败

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

查看调试的进程：info inferiors

切换当前调试的进程：inferior id

使进程脱离 GDB 调试：detach inferiors id

四、exec函数族

1、exec 函数族介绍

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

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

2、exec 函数族作用图解

3、exec 函数族

int execl(const char *path, const char *arg, … (char *) NULL );

执行我们生成的程序

#include <unistd.h>
extern char **environ;

int execl(const char *path, const char *arg, ...);
参数：

• path:需要指定的执行文件的路径或者名称

• a.out（相对路径） 或者 /home/qykhhr/a.out（绝对路径）

• arg:是执行可执行文件所需要的参数列表

  • 第一个参数没有什么作用，为了方便，一般写的是可执行的程序的名称
  • 从第二个参数开始往后，就是程序执行所需要的参数列表
  • 参数最后要以NULL结束（哨兵）

返回值：只有调用失败或者错误的时候才会有返回值，返回 -1，并设置errno；如果调用成功，不会有返回值

/*
#include <unistd.h>
extern char **environ;int execl(const char *path, const char *arg, ...);参数：- path:需要指定的执行文件的路径或者名称a.out（相对路径） 或者 /home/qykhhr/a.out（绝对路径）- arg:是执行可执行文件所需要的参数列表第一个参数没有什么作用，为了方便，一般写的是可执行的程序的名称从第二个参数开始往后，就是程序执行所需要的参数列表参数最后要以NULL结束（哨兵）返回值：只有调用失败或者错误的时候才会有返回值，返回 -1，并设置errno；如果调用成功，不会有返回值
*/
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
int main()
{// 创建一个子进程，在子进程中执行 exec函数族中的函数pid_t pid = fork();if(pid > 0) {// 父进程printf("I am parent process, pid = %d\n",getpid());// 睡眠 1s，防止父进程过快结束，子进程成为孤儿进程sleep(1);}else if(pid == 0){printf("I am child process1, pid = %d\n",getpid());// 子进程execl("hello","hello",NULL);printf("I am child process2, pid = %d\n",getpid());}for(int i = 0;i < 10; i++){printf("i = %d,pid = %d\n",i ,getpid());}return 0;
}

执行系统程序

execl("/bin/ps","ps","aux",NULL);

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
int main()
{// 创建一个子进程，在子进程中执行 exec函数族中的函数pid_t pid = fork();if(pid > 0) {// 父进程printf("I am parent process, pid = %d\n",getpid());// 睡眠 1s，防止父进程过快结束，子进程成为孤儿进程sleep(1);}else if(pid == 0){printf("I am child process1, pid = %d\n",getpid());// 子进程execl("/bin/ps","ps","aux",NULL);printf("I am child process2, pid = %d\n",getpid());}for(int i = 0;i < 10; i++){printf("i = %d,pid = %d\n",i ,getpid());}return 0;
}

int execlp(const char *file, const char arg, … / (char *) NULL */);

作用：与execl不同的是，这个函数会到环境变量中查找指定的可执行文件，如果找到了就执行，找不到就执行不成功

execlp("ps","ps","aux",NULL); – 成功

execlp("a.out","a.out",NULL); – 失败

/*#include <unistd.h>
extern char **environ;
int execlp(const char *file, const char *arg, ...);作用：与execl不同的是，这个函数会到环境变量中查找指定的可执行文件，如果找到了就执行，找不到就执行不成功参数：- path:需要指定的执行文件的路径或者名称a.out（相对路径） 或者 /home/qykhhr/a.out（绝对路径）- arg:是执行可执行文件所需要的参数列表第一个参数没有什么作用，为了方便，一般写的是可执行的程序的名称从第二个参数开始往后，就是程序执行所需要的参数列表参数最后要以NULL结束（哨兵）返回值：只有调用失败或者错误的时候才会有返回值，返回 -1，并设置errno；如果调用成功，不会有返回值
*/
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
int main()
{// 创建一个子进程，在子进程中执行 exec函数族中的函数pid_t pid = fork();if(pid > 0) {// 父进程printf("I am parent process, pid = %d\n",getpid());// 睡眠 1s，防止父进程过快结束，子进程成为孤儿进程sleep(1);}else if(pid == 0){printf("I am child process1, pid = %d\n",getpid());// 子进程int ret = execlp("ps","ps","aux",NULL);// int ret = execlp("1-fork","ps","aux",NULL); // 错误，没有指定位置，环境变量中也没有// int ret = execlp("./1-fork","ps","aux",NULL);// 指定了位置，当前目录下的应用程序if(ret == -1){perror("execlp");return -1;}printf("I am child process2, pid = %d\n",getpid());}for(int i = 0;i < 10; i++){printf("i = %d,pid = %d\n",i ,getpid());}return 0;
}

int execle(const char *path, const char *arg, …, (char *) NULL, char * const envp[] );

/*
与 execlp 函数不同的是 我们可以指定路径，该函数会到环境变量和我们传入的路径中找到程序并执行
*/
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{pid_t pid = fork();if(pid == -1){perror("fork");return -1;}if(pid > 0){// 父进程printf("this is parent process, pid = %d, ppid = %d\n",getpid(), getppid());sleep(1);}else{printf("this is child process, pid = %d, ppid = %d\n",getpid(),getppid());char * envp = "./"; // 指定环境变量int ret = execle("1-fork","1-fork",envp,NULL);// int ret = execle("ps","ps","aux",NULL); // execlp: No such file or directoryif(ret == -1){perror("execlp");return -1;}}return 0;
}

int execv(const char *path, char *const argv[]);

argv 是需要的参数的一个字符串数组

char * argv[] = {"ps", "aux", NULL};
execv("/bin/ps",argv);

/*
与 execl 函数不同的是 我们将执行的参数封装到 char * 数组中
*/
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{pid_t pid = fork();if(pid == -1){perror("fork");return -1;}if(pid > 0){// 父进程printf("this is parent process, pid = %d, ppid = %d\n",getpid(), getppid());sleep(1);}else{printf("this is child process, pid = %d, ppid = %d\n",getpid(),getppid());char * argv[] = {"ps","aux",NULL}; // 执行的参数封装成一个指针数组int ret = execv("/bin/ps",argv);if(ret == -1){perror("execlp");return -1;}}return 0;
}

int execvp(const char *file, char *const argv[]);

int execvpe(const char *file, char *const argv[], char *const envp[]);

char * argv[] = {"ps", "aux", NULL};
// 自定义到哪些路径下找
char * envp[] = {"/home/qykhhr","/home/bbb","/home/aaa"};
execvpe("/bin/ps",argv,envp);

/*
execvpe 函数是Linux系统函数
*/
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{pid_t pid = fork();if(pid == -1){perror("fork");return -1;}if(pid > 0){// 父进程printf("this is parent process, pid = %d, ppid = %d\n",getpid(), getppid());sleep(1);}else{printf("this is child process, pid = %d, ppid = %d\n",getpid(),getppid());char * argv[] = {"ps","aux",NULL}; // 执行的参数封装成一个指针数组char * envp[] = {"/home/qykhhr","/home/qykhhr/Linux2"};int ret = execvpe("ps",argv,envp);if(ret == -1){perror("execlp");return -1;}}return 0;
}

（Linux系统函数,上面的都是标准C库函数）int execve(const char *filename, char *const argv[], char *const envp[]);

• l(list) 参数地址列表，以空指针结尾
• v(vector) 存有各参数地址的指针数组的地址
• p(path) 按 PATH 环境变量指定的目录搜索可执行文件
• e(environment) 存有环境变量字符串地址的指针数组的地址

五、进程控制

1、进程退出

// 标准C库
#include <stdlib.h>
void exit (int status);
// Linux系统函数
#include <unistd.h>
void _exit (int status);

exit(status)

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

qykhhr@qykhhr:~/Linux/lesson20$ ./exit 
hello
worldqykhhr@qykhhr:~/Linux/lesson20$

_exit(status)

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

qykhhr@qykhhr:~/Linux/lesson20$ ./exit 
hello
qykhhr@qykhhr:~/Linux/lesson20$

exit(status);是标准C库函数，在关闭前会调用退出处理函数并刷新I/O缓冲，关闭文件描述符。

printf()是标准C库函数，具有缓冲区。

printf("hello\n");在换行的时候会刷新I/O缓冲（也可以调用fflush函数刷新缓冲），而printf("world");并没有刷新I/O缓冲。

我们调用exit(status)函数完成进程退出，会刷新I/O缓冲，所以world可以正常打印；

而调用Linux系统函数_exit时，不会刷新I/O缓冲，而上一行程序printf("hello\n")在执行换行时已经刷新I/O了所以程序的运行结果只是打印了hello，后面的printf("world")执行了，但是由于I/O缓冲没有刷新，进程就退出了，导致数据并没有显示。

2、孤儿进程

父进程运行结束后，但子进程还在运行（未运行结束），这样的子进程就称为孤儿进程（Orphan Process）。

每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为 init，而 init 进程会循环地 wait() 它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init 进程就会代表党和政府出门处理它的一切善后工作。

因此孤儿进程并不会有什么危害。

#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){// 子进程睡眠 1s，父进程先结束，子进程就成为了孤儿进程，内核会把孤儿进程的父进程设置为1号进程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;
}

当前终端运行程序，终端程序变为后台程序，前台程序的输出打印到当前终端上；父进程结束后，终端进程由后台转为了前台，但是运行的进程还有一个子进程没有结束，子进程的打印也会接着输出到终端上。

qykhhr@qykhhr:~/Linux/lesson20$ ./orphanprocess 
I am parent process, pid=5641, ppid=5479
i=0, pid=5641
i=1, pid=5641
i=2, pid=5641
qykhhr@qykhhr:~/Linux/lesson20$ I am child process, pid=5642, ppid=1
i=0, pid=5642
i=1, pid=5642
i=2, pid=5642

3、僵尸进程

每个进程结束之后，都会释放自己地址空间中的用户区数据，内核区的 PCB 没有办法自己释放掉，需要父进程去释放。

进程终止时，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸（Zombie）进程。

僵尸进程不能被 kill -9 杀死，这样就会导致一个问题，如果父进程不调用 wait() 或 waitpid() 的话，那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵尸进程，将因为没有可用的进程号而导致不能新的进程，此即为僵尸进程的危害，应当避免。

我们可以通过终止父进程来让1号进程来对进程资源进行回收。

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>int main()
{// 创建一个子进程pid_t pid = fork();if(pid > 0){while(1){// 父进程一直运行且没有回收子进程的内核区（PCB），会导致僵尸进程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;
}

qykhhr@qykhhr:~/Linux/lesson20$ ./zombie 
I am parent process, pid=5690, ppid=5479
I am child process, pid=5691, ppid=5690
i=0, pid=5691
i=1, pid=5691
i=2, pid=5691
I am parent process, pid=5690, ppid=5479
I am parent process, pid=5690, ppid=5479
I am parent process, pid=5690, ppid=5479
I am parent process, pid=5690, ppid=5479
I am parent process, pid=5690, ppid=5479
......

4、进程回收

在每个进程退出的时候，内核释放该进程所有的资源、包括打开的文件、占用的内存等。但是仍然为其保留一定的信息，这些信息主要主要指进程控制块 PCB 的信息（包括进程号、退出状态、运行时间等）。

父进程可以通过调用 wait 或 waitpid 得到它的退出状态同时彻底清除掉这个进程。

wait() 和 waitpid() 函数的功能一样，区别在于， wait() 函数会阻塞，waitpid() 可以设置不阻塞， waitpid() 还可以指定等待哪个子进程结束。

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

pid_t wait(int *status)

/*
#include <sys/types.h>
#include <sys/wait.h>pid_t wait(int *wstatus);作用：等待任意一个子进程的结束，如果任意一个子进程结束了，此函数就会回收子进程的资源参数：int *wstatus进程退出时的状态信息，传入的时一个int类型的指针，传出参数返回值：成功：返回被回收的子进程的id失败：返回-1，（所有的子进程都结束，调用函数失败）
调用wait函数的进程会被挂起（阻塞），直到它的一个子进程退出或者收到一个不能被忽略的信号时才会被唤醒（相当于继续往下执行）。
如果没有了子进程，函数立即返回-1；如果子进程都已经结束了，也会立即返回-1。
*/
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{// 有一个父进程，创建5个子进程（兄弟）pid_t pid = -1;for(int i = 0; i < 5; i++){pid = fork();// 如果是子进程就跳出循环，不让子进程继续创建进程，只让父进程创建进程if(pid == 0){break;}else if(pid == -1){perror("fork");return -1;}}if(pid > 0){// 父进程pid_t ret = -1;while(1){printf("This is parent process! pid = %d, ppid = %d\n",getpid(),getppid());// 程序调用wait成功返回子进程的pid，失败返回-1ret = wait(NULL);if(ret == -1){printf("所有子进程都回收完成，调用函数失败！\n");return 0;}printf("child process is die!,The id is %d\n",ret);}}else{// 子进程printf("This is child process! pid = %d, ppid = %d\n",getpid(),getppid());sleep(1);}return 0;
}

qykhhr@qykhhr:~/Linux2$ gcc 13-wait.c -o 13-wait
qykhhr@qykhhr:~/Linux2$ ./13-wait 
This is parent process! pid = 7744, ppid = 4130
This is child process! pid = 7745, ppid = 7744
This is child process! pid = 7748, ppid = 7744
This is child process! pid = 7746, ppid = 7744
This is child process! pid = 7749, ppid = 7744
This is child process! pid = 7747, ppid = 7744
child process is die!,The id is 7747
This is parent process! pid = 7744, ppid = 4130
child process is die!,The id is 7745
This is parent process! pid = 7744, ppid = 4130
child process is die!,The id is 7746
This is parent process! pid = 7744, ppid = 4130
child process is die!,The id is 7748
This is parent process! pid = 7744, ppid = 4130
child process is die!,The id is 7749
This is parent process! pid = 7744, ppid = 4130
所有子进程都回收完成，调用函数失败！

pid_t waitpid(pid_t pid, int *wstatus, int options);

#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *wstatus, int options);
作用：等待任意一个子进程的结束，如果任意一个子进程结束了，此函数就会回收子进程的资源
参数：

• int *wstatus
  • 进程退出时的状态信息，传入的时一个int类型的指针，传出参数
• 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>
pid_t waitpid(pid_t pid, int *wstatus, int options);作用：等待任意一个子进程的结束，如果任意一个子进程结束了，此函数就会回收子进程的资源参数：int *wstatus进程退出时的状态信息，传入的时一个int类型的指针，传出参数pidpid > 0 : 某个子进程的pidpid = 0 : 回收当前进程组的所有子进程pid = -1 : 回收所有子进程，相当于wait()pid < -1 : 某个进程组的组id的绝对值，回收指定进程组中的子进程options：设置阻塞或者非阻塞0 : 阻塞WNOHANG : 非阻塞返回值：> 0 : 返回子进程的id= 0 : options=WNOHANG，表示还有子进程活着= -1 : 错误，或者没有子进程了
*/
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{pid_t pid = -1;for(int i = 0; i < 5; i++){pid = fork();if(pid == 0){break;}}if(pid > 0){while(1){printf("This is parent process,pid = %d\n",getpid());int ret = waitpid(-1,NULL,0);if(ret == -1){printf("子线程全部回收完毕！\n");return 0;}printf("child process id die, pid = %d\n",ret);sleep(1);}}else{while(1){printf("This is child process, pid = %d, ppid = %d\n",getpid(),getppid());sleep(2);}}return 0;
}

qykhhr@qykhhr:~/Linux2$ gcc 14-waitpid.c -o 14-waitpid
qykhhr@qykhhr:~/Linux2$ ./14-waitpid 
This is parent process,pid = 7812
This is child process, pid = 7813, ppid = 7812
This is child process, pid = 7814, ppid = 7812
This is child process, pid = 7816, ppid = 7812
This is child process, pid = 7817, ppid = 7812
This is child process, pid = 7815, ppid = 7812
This is child process, pid = 7814, ppid = 7812
This is child process, pid = 7816, ppid = 7812
This is child process, pid = 7815, ppid = 7812
child process id die, pid = 7813
This is parent process,pid = 7812
This is child process, pid = 7816, ppid = 7812
This is child process, pid = 7814, ppid = 7812
This is child process, pid = 7817, ppid = 7812
This is child process, pid = 7815, ppid = 7812
This is child process, pid = 7817, ppid = 7812
child process id die, pid = 7814
This is parent process,pid = 7812
This is child process, pid = 7816, ppid = 7812
This is child process, pid = 7817, ppid = 7812
This is child process, pid = 7815, ppid = 7812
child process id die, pid = 7815
This is child process, pid = 7816, ppid = 7812
This is child process, pid = 7817, ppid = 7812
This is parent process,pid = 7812
child process id die, pid = 7816
This is parent process,pid = 7812
This is child process, pid = 7817, ppid = 7812
child process id die, pid = 7817
This is parent process,pid = 7812
子线程全部回收完毕！

/*
#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *wstatus, int options);作用：等待任意一个子进程的结束，如果任意一个子进程结束了，此函数就会回收子进程的资源参数：int *wstatus进程退出时的状态信息，传入的时一个int类型的指针，传出参数pidpid > 0 : 某个子进程的pidpid = 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;for(int i = 0; i < 5; i++){pid = fork();// 如果是子进程就跳出循环，不让子进程继续创建进程，只让父进程创建进程if(pid == 0){break;}}if(pid > 0){// 父进程while(1){printf("parent,pid = %d\n",getpid());// 程序调用wait成功返回子进程的pid，失败返回-1int st;int ret = waitpid(-1,&st,0);if(ret == -1){break;}// W IF EXIT EDif(WIFEXITED(st)){// W(wait) EXIT(exit) STATUS(status)// 是不是正常退出printf("退出的状态码：%d\n",WEXITSTATUS(st));}// W IF SIGNAL EDif(WIFSIGNALED(st)){// W(wait) TERM(term) SIG(signal)// 是不是异常终止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;
}

只有在子进程结束后，父进程才打印一句parent, pid = 3327，父进程一直在阻塞等待回收子进程。

qykhhr@qykhhr:~/Linux2$ gcc 15-waitpid2.c -o 15-waitpid2
qykhhr@qykhhr:~/Linux2$ ./15-waitpid2 
This is child process, pid = 7896, ppid = 7895
This is parent process,pid = 7895
This is child process, pid = 7897, ppid = 7895
This is child process, pid = 7899, ppid = 7895
This is child process, pid = 7898, ppid = 7895
This is child process, pid = 7900, ppid = 7895
This is child process, pid = 7899, ppid = 7895
This is child process, pid = 7896, ppid = 7895
This is child process, pid = 7900, ppid = 7895
This is child process, pid = 7897, ppid = 7895
This is child process, pid = 7898, ppid = 7895
This is child process, pid = 7899, ppid = 7895
被9信号杀死了
child process id die, pid = 7896
This is parent process,pid = 7895
This is child process, pid = 7900, ppid = 7895
This is child process, pid = 7897, ppid = 7895
This is child process, pid = 7898, ppid = 7895
This is child process, pid = 7899, ppid = 7895
被9信号杀死了
child process id die, pid = 7897
This is parent process,pid = 7895
This is child process, pid = 7899, ppid = 7895
This is child process, pid = 7900, ppid = 7895
This is child process, pid = 7898, ppid = 7895
被9信号杀死了
child process id die, pid = 7898
This is parent process,pid = 7895
被9信号杀死了
child process id die, pid = 7899
This is child process, pid = 7900, ppid = 7895
This is parent process,pid = 7895
This is child process, pid = 7900, ppid = 7895
This is child process, pid = 7900, ppid = 7895
被9信号杀死了
child process id die, pid = 7900
This is parent process,pid = 7895
子线程全部回收完毕！

非阻塞

/*
#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *wstatus, int options);作用：等待任意一个子进程的结束，如果任意一个子进程结束了，此函数就会回收子进程的资源参数：int *wstatus进程退出时的状态信息，传入的时一个int类型的指针，传出参数pidpid > 0 : 某个子进程的pidpid = 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;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);// 程序调用wait成功返回子进程的pid，失败返回-1int st;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;
}

5、退出信息相关宏函数

WIFEXITED(status) 非 0 ，判断进程正常退出

• W：wait
• IF：if
• EXIT：exit
• ED：end

WEXITSTATUS(status) 如果上宏为真，获取进程退出的状态（ exit 的参数）

• W：wait
• EXIT：exit
• STATUS：status

WIFSIGNALED(status) 非 0 ，判断进程是否异常终止

• W：wait
• IF：if
• SIGNAL：signal
• ED：end

WTERMSIG(status) 如果上宏为真，获取使进程终止的信号编号

• W：wait
• TERM：term（终止）
• SIG：signal

WIFSTOPPED(status) 非 0 ，判断进程是否处于暂停状态

• W：wait
• IF：if
• STOP：stop
• P：process
• ED：end

WSTOPSIG(status) 如果上宏为真，获取使进程暂停的信号的编号

• W：wait
• STOP：stop
• SIG：signal

WIFCONTINUED(status) 非 0 ，进程暂停后已经继续运行

/*
#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>int main()
{// 有一个父进程，创建5个子进程（兄弟）pid_t pid;for(int i = 0; i < 5; i++){pid = fork();// 如果是子进程就跳出循环，不让子进程继续创建进程，只让父进程创建进程if(pid == 0){break;}}if(pid > 0){// 父进程while(1){printf("parent,pid = %d\n",getpid());// 程序调用wait成功返回子进程的pid，失败返回-1int 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){// 子进程 printf("child,pid = %d\n",getpid());}return 0;
}

qykhhr@qykhhr:~/Linux/lesson21$ ./waitpid 
child,pid = 6043
child,pid = 6044
parent,pid = 6042
child,pid = 6046
退出的状态码：0
child die, pid = 6043
child,pid = 6047
child,pid = 6045
parent,pid = 6042
退出的状态码：0
child die, pid = 6044
parent,pid = 6042
退出的状态码：0
child die, pid = 6045
parent,pid = 6042
退出的状态码：0
child die, pid = 6046
parent,pid = 6042
退出的状态码：0
child die, pid = 6047
parent,pid = 6042

六、进程间通信

1、进程间通信概念

进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。

但是，进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因为需要进程间通信（IPC：Inter Processes Communication）。

进程间通信的目的：

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

2、Linux 进程间通信方式

3、匿名管道

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

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

|是管道符。

4、管道的特点

管道其实是一个在内核内存中维护的缓冲器，这个缓冲器的存储能力是有限的，不同的操作系统大小不一定相同。

管道拥有文件的特质：读操作、写操作，匿名管道没有文件实体，有名管道有文件实体，但不存储数据。可以按照操作文件的方式对管道进行操作。

一个管道是一个字节流，使用管道时不存在消息或者消息边界的概念，从管道读取数据的进程可以读取任意大小的数据块，而不管写入进程写入管道的数据块的大小是多少。

通过管道传递的数据是有序的，从管道中读取出来的字节顺序和它们被写入管道的顺序是完全一样的。

在管道中的数据的传递方向是单向的，一端用于写入，一端用于读取，管道是半双工的。

从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写更多的数据，在管道中无法使用 lseek() 来随机的访问数据。

匿名管道只能在具有公共祖先的进程（父进程与子进程，或者两个兄弟进程，具有亲缘关系）之间可以使用。

5、为什么可以使用管道进行进程间通信

进程间共享文件描述符

6、管道的数据方向

环形队列：避免资源浪费

7、匿名管道的使用

1）、创建匿名管道

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

子进程发送一条数据给父进程，父进程读取到数据输出到控制台

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

• 功能：创建一个匿名管道，用来进程间通信
• 参数：int pipefd[2] 这个数组是一个传出参数。
  • pipefd[0] 对应的是管道读端
  • pipefd[1] 对应的是管道写端
• 返回值：成功返回 0，失败返回 -1

管道默认是阻塞的：如果管道中没有数据，read 阻塞；如果管道满了，write 阻塞
注意：匿名管道只能用于具有关系的进程之间的通信（父子进程，兄弟进程），主要是因为这些进程可以共享文件描述符

/*
#include <unistd.h>
int pipe(int pipefd[2]);功能：创建一个匿名管道，用来进程间通信参数：int pipefd[2] 这个数组是一个传出参数。pipefd[0] 对应的是管道读端pipefd[1] 对应的是管道写端返回值：成功返回 0，失败返回 -1管道默认是阻塞的：如果管道中没有数据，read 阻塞；如果管道满了，write 阻塞
注意：匿名管道只能用于具有关系的进程之间的通信（父子进程，兄弟进程），主要是因为这些进程可以共享文件描述符*/
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>// 子进程发送数据给父进程，父进程读取到数据输出到控制台
int main()
{// 在 fork 之前创建管道，fork之后，父子进程就是共享同一个文件描述符了int pipefd[2];int ret = pipe(pipefd);if(ret == -1){perror("pipe函数");exit(0);}// 创建子进程pid_t pid = fork();if(pid > 0){// 父进程printf("parent pid = %d\n",getpid());// 此处不需要阻塞，应为 read 函数在管道没有数据时就是阻塞的// sleep(1);// 从管道的读取端读取子进程发送的数据// buf数组初始化为0，子进程写入时长度可以按照实际的字符串长度，如果没有初始化成0，那么就要将字符串末尾的 \0 也要算一个长度，否则打印出来会出现错误char buf[1024] = {0};int len = read(pipefd[0],buf,sizeof(buf));printf("parent receive: %s,pid=%d\n",buf,getpid());}else if(pid == 0){// 子进程阻塞10s，父进程也会阻塞等待10s来读取管道中的数据// sleep(10);// 子进程printf("child pid = %d\n",getpid());// 从管道的写入端写入数据char * str = "hello,I am child process!";write(pipefd[1],str,strlen(str));}return 0;
}

qykhhr@qykhhr:~/Linux/lesson22$ ./pipe 
parent pid = 3628
child pid = 3629
parent receive: hello,I am child process!,pid=3628

子进程连续发送数据，父进程连续读取子进程的数据

#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>// 子进程发送数据给父进程，父进程读取到数据输出到控制台
int main()
{// 在 fork 之前创建管道，fork之后，父子进程就是共享同一个文件描述符了int pipefd[2];int ret = pipe(pipefd);if(ret == -1){perror("pipe函数");exit(0);}// 创建子进程pid_t pid = fork();if(pid > 0){// 父进程printf("parent pid = %d\n",getpid());char buf[1024] = {0};while(1){// 从管道的读取端读取子进程发送的数据int len = read(pipefd[0],buf,sizeof(buf));printf("parent receive: %s,pid=%d\n",buf,getpid());// 这里不需要睡眠，管道有多少数据就需要读取数据，没有数据就会阻塞}}else if(pid == 0){// 子进程阻塞10s，父进程也会阻塞等待10s来读取管道中的数据// sleep(10);// 子进程printf("child pid = %d\n",getpid());while(1){// 从管道的写入端写入数据char * str = "hello,I am child process!";write(pipefd[1],str,strlen(str));sleep(1);}}return 0;
}

qykhhr@qykhhr:~/Linux/lesson22$ ./pipe 
parent pid = 3649
child pid = 3650
parent receive: hello,I am child process!,pid=3649
parent receive: hello,I am child process!,pid=3649
parent receive: hello,I am child process!,pid=3649
parent receive: hello,I am child process!,pid=3649
.......

子进程连续发送消息并且读取数据，父进程连续读取消息并且发送数据

两个进程必须是一个先发送一个先接受，不能两个进程都从管道中读取数据，这样的话就会发生阻塞。

/*
#include <unistd.h>
int pipe(int pipefd[2]);功能：创建一个匿名管道，用来进程间通信参数：int pipefd[2] 这个数组是一个传出参数。pipefd[0] 对应的是管道读端pipefd[1] 对应的是管道写端返回值：成功返回 0，失败返回 -1管道默认是阻塞的：如果管道中没有数据，read 阻塞；如果管道满了，write 阻塞
注意：匿名管道只能用于具有关系的进程之间的通信（父子进程，兄弟进程），主要是因为这些进程可以共享文件描述符*/
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>// 子进程发送数据给父进程，父进程读取到数据输出到控制台
int main()
{// 在 fork 之前创建管道，fork之后，父子进程就是共享同一个文件描述符了int pipefd[2];int ret = pipe(pipefd);if(ret == -1){perror("pipe函数");exit(0);}// 创建子进程pid_t pid = fork();if(pid > 0){// 父进程printf("parent pid = %d\n",getpid());char buf[1024] = {0};while(1){// 从管道的读取端读取子进程发送的数据int len = read(pipefd[0],buf,sizeof(buf));printf("parent receive: %s,pid=%d\n",buf,getpid());// 这里不需要睡眠，管道有多少数据就需要读取数据，没有数据就会阻塞// 从管道的写入端写入数据char * str = "hello,I am parent process!";write(pipefd[1],str,strlen(str));// 向管道写入数据后不要立马就去读，很可能会将自己刚写入管道的数据又读取走了sleep(1);}}else if(pid == 0){// 子进程阻塞10s，父进程也会阻塞等待10s来读取管道中的数据// sleep(10);// 子进程printf("child pid = %d\n",getpid());char buf[1024] = {0};while(1){// 从管道的写入端写入数据char * str = "hello,I am child process!";write(pipefd[1],str,strlen(str));// 向管道写入数据后不要立马就去读，很可能会将自己刚写入管道的数据又读取走了sleep(1);// 从管道的读取端读取子进程发送的数据int len = read(pipefd[0],buf,sizeof(buf));printf("child receive: %s,pid=%d\n",buf,getpid());// 读取后将buf重置，防止影响到下次读取的内容bzero(buf,1024);}}return 0;
}

qykhhr@qykhhr:~/Linux/lesson22$ ./pipe 
parent pid = 4422
child pid = 4423
parent receive: hello,I am child process!,pid=4422
child receive: hello,I am parent process!,pid=4423
parent receive: hello,I am child process!,pid=4422
parent receive: hello,I am parent process!,pid=4422
child receive: hello,I am parent process!,pid=4423
parent receive: hello,I am child process!!,pid=4422
child receive: hello,I am parent process!,pid=4423
child receive: hello,I am child process!,pid=4423
......

2）、查看管道缓冲大小命令

ulimit -a

qykhhr@qykhhr:~/Linux/lesson22$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 15435
max locked memory       (kbytes, -l) 65536
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 15435
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

一块大小为 512 字节，一共有 8 块，总共是 4096 字节（4 K），可以使用 ulimit -p xx 修改管道大小

pipe size            (512 bytes, -p) 8

3）、查看管道缓冲大小函数

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

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

qykhhr@qykhhr:~/Linux/lesson22$ ./fpathconf 
pipe size=4096

4）、父子进程相互发送读取管道数据会发生错误

我们注释掉子进程中的sleep(1)函数后，程序执行到子进程，子进程先向管道写入数据，然后又立刻将数据读取出来了，我们要避免这种情况，不要使用管道互相通信，要明确方向。

#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>// 子进程发送数据给父进程，父进程读取到数据输出到控制台
int main()
{// 在 fork 之前创建管道，fork之后，父子进程就是共享同一个文件描述符了int pipefd[2];int ret = pipe(pipefd);if(ret == -1){perror("pipe函数");exit(0);}// 创建子进程pid_t pid = fork();if(pid > 0){// 父进程printf("parent pid = %d\n",getpid());char buf[1024] = {0};while(1){// 从管道的读取端读取子进程发送的数据int len = read(pipefd[0],buf,sizeof(buf));printf("parent receive: %s,pid=%d\n",buf,getpid());// 这里不需要睡眠，管道有多少数据就需要读取数据，没有数据就会阻塞// 从管道的写入端写入数据char * str = "hello,I am parent process!";write(pipefd[1],str,strlen(str));// 向管道写入数据后不要立马就去读，很可能会将自己刚写入管道的数据又读取走了//sleep(1);}}else if(pid == 0){// 子进程阻塞10s，父进程也会阻塞等待10s来读取管道中的数据// sleep(10);// 子进程printf("child pid = %d\n",getpid());char buf[1024] = {0};while(1){// 从管道的写入端写入数据char * str = "hello,I am child process!";write(pipefd[1],str,strlen(str));// 注释掉睡眠，会出现写入管道的数据，自己立马又读取出来了// 向管道写入数据后不要立马就去读，很可能会将自己刚写入管道的数据又读取走了//sleep(1);// 从管道的读取端读取子进程发送的数据int len = read(pipefd[0],buf,sizeof(buf));printf("child receive: %s,pid=%d\n",buf,getpid());// 读取后将buf重置，防止影响到下次读取的内容bzero(buf,1024);}}return 0;
}

child receive: hello,I am child process!,pid=4432
child receive: hello,I am child process!,pid=4432
child receive: hello,I am child process!,pid=4432
child receive: hello,I am child process!,pid=4432
child receive: hello,I am child process!,pid=4432
child receive: hello,I am child process!,pid=4432
child receive: hello,I am child process!,pid=4432
child receive: hello,I am child process!,pid=4432
child receive: hello,I am child process!,pid=4432
child receive: hello,I am child process!,pid=4432
child receive: hello,I am child process!,pid=4432
child receive: hello,I am child process!,pid=4432
child receive: hello,I am child process!,pid=4432
child receive: hello,I am child process!,pid=4432
child receive: hello,I am child process!,pid=4432
child receive: hello,I am child process!,pid=4432
......

我们需要明确两个进程对管道的写端和读端，可以通过 close(pipefd[0]); 来关闭读端，close(pipefd[1]);关闭写端。

/*
我们注释掉子进程中的`sleep(1)`函数后，
程序执行到子进程，子进程先向管道写入数据，
然后又立刻将数据读取出来了，我们要避免这种情况，不要使用管道互相通信，要明确方向。
*/
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <string.h>int main()
{int pipefd[2];int ret = pipe(pipefd);if(ret == -1){perror("pipe");return -1;}pid_t pid = fork();if(pid == -1){perror("fork");return -1;}else if(pid > 0){// 父进程printf("parent pid = %d\n",getpid());// 关闭写端close(pipefd[1]);char buf[1024];while(1){int len = read(pipefd[0],buf,sizeof(buf));if(len == -1){perror("read");return -1;}printf("parent recving data:%s\n",buf);}}else{// 子进程printf("child pid = %d\n",getpid());// 关闭读端close(pipefd[0]);char buf[1024] = {0};int num = 0;while(1){sprintf(buf,"hello,I am child process! num = %d",num++);int len = write(pipefd[1],buf,strlen(buf) + 1);if(len == -1){perror("write");return -1;}memset(buf,0,sizeof(buf));sleep(1);}}return 0;
}

qykhhr@qykhhr:~/Linux2$ gcc 21-pipe.c -o 21-pipe
qykhhr@qykhhr:~/Linux2$ ./21-pipe 
parent recving data:hello,I am child process! num = 0
parent recving data:hello,I am child process! num = 1
parent recving data:hello,I am child process! num = 2
parent recving data:hello,I am child process! num = 3
parent recving data:hello,I am child process! num = 4
parent recving data:hello,I am child process! num = 5
parent recving data:hello,I am child process! num = 6
parent recving data:hello,I am child process! num = 7
parent recving data:hello,I am child process! num = 8
parent recving data:hello,I am child process! num = 9
parent recving data:hello,I am child process! num = 10
parent recving data:hello,I am child process! num = 11
parent recving data:hello,I am child process! num = 12
parent recving data:hello,I am child process! num = 13
parent recving data:hello,I am child process! num = 14
parent recving data:hello,I am child process! num = 15
......

5）、实现 ps aux | grep xxx 父子间通信

/*
实现 ps aux | grep xxx 父子间通信
子进程: ps aux ，子进程结束后，将数据发送给父进程
父进程：获取到数据，过滤
pipe() 获取匿名管道
execlp() 执行 ps aux 命令
dup2() 子进程将标准输出 stdout_fileno 重定向到管道的写端。
*/
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <wait.h>int main()
{// 创建一个管道int pipefd[2];int ret = pipe(pipefd);if(ret == -1){perror("pipe函数");exit(-1);}// 创建管道后再创建子进程，这样父子进程的文件描述符才执行同一个管道，进而才能实现通信pid_t pid = fork();if(pid > 0){// 父进程// 父进程的目的是向管道读取数据，我们先关闭写端close(pipefd[1]);// 从管道获取数据char buf[1024] = {0};// sizeof(buf) - 1 ：留一个字符串结束符\0int len = -1;while((len = read(pipefd[0],buf,sizeof(buf) - 1)) > 0){// 过滤数据输出printf("%s",buf);// 清空数组内容memset(buf,0,1024);}// 回收子进程的资源wait(NULL);}else if(pid == 0){// 关闭管道的读端close(pipefd[0]);// 子进程// 将 FD 复制到 FD2，关闭 FD2 并使其在同一文件上打开。// 将文件描述符重定向，让下面的输出结果写入到管道中// 文件描述符的重定向， stdout_fileno --> fd[1]dup2(pipefd[1],STDOUT_FILENO);// 执行 ps aux，// 第一个参数：执行的命令// 第二个参数，执行的命令的名字// 第三个参数：执行的命令后面的第一个参数// 第四个参数：文件结尾标识execlp("ps","ps","aux",NULL);perror("execlp函数");exit(0);}else{perror("fork函数");exit(-1);}return 0;
}

qykhhr@qykhhr:~/Linux2$ gcc 22-pipe-execl.c -o 22-pipe-execl
qykhhr@qykhhr:~/Linux2$ ./22-pipe-execl 
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root          1  0.0  0.2 225312  8992 ?        Ss   07:32   0:01 /sbin/init splash
root          2  0.0  0.0      0     0 ?        S    07:32   0:00 [kthreadd]
root          3  0.0  0.0      0     0 ?        I<   07:32   0:00 [rcu_gp]
root          4  0.0  0.0      0     0 ?        I<   07:32   0:00 [rcu_par_gp]
root          5  0.0  0.0      0     0 ?        I    07:32   0:00 [kworker/0:0-cgr]
root          6  0.0  0.0      0     0 ?        I<   07:32   0:00 [kworker/0:0H-kb]
root          9  0.0  0.0      0     0 ?        I<   07:32   0:00 [mm_percpu_wq]
root         10  0.0  0.0      0     0 ?        S    07:32   0:00 [ksoftirqd/0]
root         11  0.0  0.0      0     0 ?        I    07:32   0:04 [rcu_sched]
root         12  0.0  0.0      0     0 ?        S    07:32   0:00 [migration/0]
root         13  0.0  0.0      0     0 ?        S    07:32   0:00 [idle_inject/0]
root         14  0.0  0.0      0     0 ?        S    07:32   0:00 0[cpuhp/0]
root         15  0.0  0.0      0     0 ?        S    07:32   0:00 [cpuhp/1]
root         16  0.0  0.0      0     0 ?        S    07:32   0:00 [idle_inject/1]
root         17  0.0  0.0      0     0 ?        S    07:32   0:00 [migration/1]
root         18  0.0  0.0      0     0 ?        S    07:32   0:00 [ksoftirqd/1]
root         20  0.0  0.0      0     0 ?        I<   07:32   0:00 [kworker/1:0H-kb]
root         21  0.0  0.0      0     0 ?        S    07:32   0:00 [cpuhp/2]
root         22  0.0  0.0      0     0 ?        S    07:32   0:00 [idle_inject/2]
......

6）、管道的读写特点

使用管道时，需要注意以下几种特殊的情况（假设都是阻塞I/O操作）

1. 所有的指向管道写端的文件描述符都关闭了（管道写端引用计数为0），有进程从管道的读端读数据，那么管道中剩余的数据被读取以后，再次read会返回0，就像读到文件末尾一样。
2. 如果有指向管道写端的文件描述符没有关闭（管道的写端引用计数大于0），而持有管道写端的进程也没有往管道中写数据，这个时候有进程从管道中读取数据，那么管道中剩余的数据被读取后，再次read会阻塞，直到管道中有数据可以读了才读取数据并返回。
3. 如果所有指向管道读端的文件描述符都关闭了（管道的读端引用计数为0），这个时候有进程向管道中写数据，那么该进程会收到一个信号SIGPIPE, 通常会导致进程异常终止。
4. 如果有指向管道读端的文件描述符没有关闭（管道的读端引用计数大于0），而持有管道读端的进程也没有从管道中读数据，这时有进程向管道中写数据，那么在管道被写满的时候再次write会阻塞，直到管道中有空位置才能再次写入数据并返回。

总结：

• 读管道：
  • 管道中有数据，read返回实际读到的字节数。
  • 管道中无数据：
    • 写端被全部关闭，read返回0（相当于读到文件的末尾）
    • 写端没有完全关闭，read阻塞等待
• 写管道：
  • 管道读端全部被关闭，进程异常终止（进程收到SIGPIPE信号）
  • 管道读端没有全部关闭：
    • 管道已满，write阻塞
    • 管道没有满，write将数据写入，并返回实际写入的字节数

7）、管道设置为非阻塞

#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.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 之前创建管道，fork之后，父子进程就是共享同一个文件描述符了int pipefd[2];int ret = pipe(pipefd);if(ret == -1){perror("pipe函数");exit(0);}// 创建子进程pid_t pid = fork();if(pid > 0){// 关闭写端close(pipefd[1]);// 父进程printf("parent pid = %d\n",getpid());char buf[1024] = {0};// 设置管道非阻塞int flags = fcntl(pipefd[0], F_GETFL);// 获取原来的flagflags |= O_NONBLOCK; // 修改 flagfcntl(pipefd[0],F_SETFL,flags);// 设置新的flagwhile(1){// 从管道的读取端读取子进程发送的数据int len = read(pipefd[0],buf,sizeof(buf));printf("len = %d\n",len);printf("parent receive: %s,pid=%d\n",buf,getpid());memset(buf,0,1024);sleep(1);}}else if(pid == 0){// 子进程阻塞10s，父进程也会阻塞等待10s来读取管道中的数据// sleep(10);// 关闭读端close(pipefd[0]);// 子进程printf("child pid = %d\n",getpid());while(1){// 从管道的写入端写入数据char * str = "hello,I am child process!";write(pipefd[1],str,strlen(str));sleep(5);}}return 0;
}

qykhhr@qykhhr:~/Linux/lesson22$ ./noblock 
parent pid = 4734
len = -1
parent receive: ,pid=4734
child pid = 4735
len = 25
parent receive: hello,I am child process!,pid=4734
len = -1
parent receive: ,pid=4734
len = -1
parent receive: ,pid=4734
len = -1
parent receive: ,pid=4734
len = 25
parent receive: hello,I am child process!,pid=4734
len = -1
......

8、有名管道

匿名管道，由于没有名字，只能用于亲缘关系的进程间通信。为了克服这个缺点，提出了有名管道（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 有名字，不相关的进程可以通过打开有名管道进行通信。

9、有名管道的使用

1）、通过命令创建有名管道

mkfifo 名字

mkfifo fifo

qykhhr@qykhhr:~/Linux/lesson23$ mkfifo fifo
qykhhr@qykhhr:~/Linux/lesson23$ ll
总用量 8
drwxrwxr-x  2 qykhhr qykhhr 4096 9月  29 21:34 ./
drwxrwxr-x 26 qykhhr qykhhr 4096 9月  29 21:34 ../
prw-rw-r--  1 qykhhr qykhhr    0 9月  29 21:34 fifo

2）、通过函数创建有名管道

#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() 等文件定位操作。

/*
创建 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，并设置errno    
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{// 先判断管道文件是否存在int ret = access("fifo1",F_OK);if(ret == -1){// 管道不存在才创建管道ret = mkfifo("fifo1",0664);if(ret == -1){perror("mkfifo函数");exit(-1);}}return 0;
}

qykhhr@qykhhr:~/Linux/lesson23$ ls
fifo  mkfifo  mkfifo.c
qykhhr@qykhhr:~/Linux/lesson23$ ./mkfifo 
qykhhr@qykhhr:~/Linux/lesson23$ ll
总用量 24
drwxrwxr-x  2 qykhhr qykhhr 4096 9月  29 21:40 ./
drwxrwxr-x 26 qykhhr qykhhr 4096 9月  29 21:34 ../
prw-rw-r--  1 qykhhr qykhhr    0 9月  29 21:34 fifo|
prw-rw-r--  1 qykhhr qykhhr    0 9月  29 21:40 fifo1|
-rwxrwxr-x  1 qykhhr qykhhr 8384 9月  29 21:40 mkfifo*
-rw-rw-r--  1 qykhhr qykhhr  634 9月  29 21:40 mkfifo.c

3）、有名管道的案例

有名管道的注意事项：
1、一个为只读时打开一个管道的进程会阻塞，直到另一个进程为只写打开管道
2、一个为只写时打开一个管道的进程会阻塞，直到另一个进程为只读打开管道
读管道：
管道中有数据，read返回实际读到的字节数
管道中无数据：
管道写端被全部关闭，read返回0（相当于读到文件末尾）
写端没有全部被关闭，read阻塞等待
写管道：
管道读端被全部关闭，进程异常终止（收到一个SIGPIPE信号）
管道读端没有全部关闭：
管道已经满了，write会阻塞
管道没有满，write将数据写入，并返回实际写入的字节数

write.c

// 向管道中写入数据#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.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){// 2、管道不存在才创建管道ret = mkfifo("test",0664);if(ret == -1){perror("mkfifo函数");exit(-1);}}// 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;
}

read.c

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

4）、有名管道实现简单版聊天功能

进程A和进程B分别操作两个管道，注意进程A写管道1，进程B必须先读取管道1的数据，再去写管道2，否则就会发生阻塞。

chatA.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
int main()
{// 判断有名管道文件是否存在int ret = access("fifo1",F_OK);if(ret == -1){// 管道文件不存在，需要创建出来printf("管道文件不存在，创建对应的管道\n");ret = mkfifo("fifo1",0664);if(ret == -1){perror("mkfifo");exit(-1);}}ret = access("fifo2",F_OK);if(ret == -1){// 管道文件不存在，需要创建出来printf("管道文件不存在，创建对应的管道\n");ret = mkfifo("fifo2",0664);if(ret == -1){perror("mkfifo");exit(-1);}}// 2、以只写的方式打开 fifo1int fdr = open("fifo1",O_RDONLY);if(fdr == -1){perror("open");exit(-1);}printf("打开fifo1成功，等待写入数据...\n");// 3、以只读的方式打开 fifo2int fdw = open("fifo2",O_WRONLY);if(fdw == -1){perror("open");exit(-1);}printf("打开fifo2成功，等待读取数据...\n");// 4、循环的写读数据char buf[128];while(1){memset(buf,0,128);// 获取标准输入的数据，不使用 scanf，因为会读取到换行就会结束fgets(buf,128,stdin);// 写数据ret = write(fdw,buf,strlen(buf));if(ret == -1){perror("write");exit(-1);}// 读管道数据memset(buf,0,128);ret = read(fdr,buf,128);if(ret <= 0){perror("read");exit(-1);}printf("buf: %s\n",buf);}close(fdr);close(fdw);
}

chatB.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
int main()
{// 判断有名管道文件是否存在int ret = access("fifo1",F_OK);if(ret == -1){// 管道文件不存在，需要创建出来printf("管道文件不存在，创建对应的管道\n");ret = mkfifo("fifo1",0664);if(ret == -1){perror("mkfifo");exit(-1);}}ret = access("fifo2",F_OK);if(ret == -1){// 管道文件不存在，需要创建出来printf("管道文件不存在，创建对应的管道\n");ret = mkfifo("fifo2",0664);if(ret == -1){perror("mkfifo");exit(-1);}}// 2、以只读的方式打开 fifo1int fdw = open("fifo1",O_WRONLY);if(fdw == -1){perror("open");exit(-1);}printf("打开fifo1成功，等待读取数据...\n");// 3、以只写的方式打开 fifo2int fdr = open("fifo2",O_RDONLY);if(fdr == -1){perror("open");exit(-1);}printf("打开fifo2成功，等待写入数据...\n");// 4、循环的写读数据char buf[128];while(1){// 读管道数据memset(buf,0,128);ret = read(fdr,buf,128);if(ret <= 0){perror("read");exit(-1);}printf("buf: %s\n",buf);memset(buf,0,128);// 获取标准输入的数据，不使用 scanf，因为会读取到换行就会结束fgets(buf,128,stdin);// 写数据ret = write(fdw,buf,strlen(buf));if(ret == -1){perror("write");exit(-1);}}close(fdr);close(fdw);
}

只能做到A先给B发，B再给A发，循环往复。

5）、有名管道复杂版聊天功能

两个进程中分别通过fork再产生各自的子进程，父进程负责写入管道数据，子进程负责读取管道数据，即使读取管道阻塞，也是子进程阻塞，父进程不会受到影响。

chatForkA.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <wait.h>
int main()
{// 判断有名管道文件是否存在int ret = access("fifo1",F_OK);if(ret == -1){// 管道文件不存在，需要创建出来printf("管道文件不存在，创建对应的管道\n");ret = mkfifo("fifo1",0664);if(ret == -1){perror("mkfifo");exit(-1);}}ret = access("fifo2",F_OK);if(ret == -1){// 管道文件不存在，需要创建出来printf("管道文件不存在，创建对应的管道\n");ret = mkfifo("fifo2",0664);if(ret == -1){perror("mkfifo");exit(-1);}}// 2、以只写的方式打开 fifo1int fdr = open("fifo1",O_RDONLY);if(fdr == -1){perror("open");exit(-1);}printf("打开fifo1成功，等待写入数据...\n");// 3、以只读的方式打开 fifo2int fdw = open("fifo2",O_WRONLY);if(fdw == -1){perror("open");exit(-1);}printf("打开fifo2成功，等待读取数据...\n");pid_t pid = fork();if(pid > 0){// 4、循环的写读数据char buf[128];// 父进程while(1){memset(buf,0,128);// 获取标准输入的数据，不使用 scanf，因为会读取到换行就会结束fgets(buf,128,stdin);// 写数据ret = write(fdw,buf,strlen(buf));if(ret == -1){perror("write");exit(-1);}}close(fdw);// 回收子进程资源wait(NULL);}else if(pid == 0){// 子进程循环的读取数据char buf[128];// 父进程while(1){// 读管道数据memset(buf,0,128);ret = read(fdr,buf,128);if(ret <= 0){perror("read");exit(-1);}printf("buf: %s\n",buf);}close(fdr);} return 0;
}

qykhhr@qykhhr:~/Linux/lesson24$ ./chatForkA
管道文件不存在，创建对应的管道
管道文件不存在，创建对应的管道
打开fifo1成功，等待写入数据...
打开fifo2成功，等待读取数据...
1
buf: 23232222
2222
3333
444
555
buf: 232buf: 32buf: 343buf: 32buf: 121

chatForkB.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <wait.h>
int main()
{// 判断有名管道文件是否存在int ret = access("fifo1",F_OK);if(ret == -1){// 管道文件不存在，需要创建出来printf("管道文件不存在，创建对应的管道\n");ret = mkfifo("fifo1",0664);if(ret == -1){perror("mkfifo");exit(-1);}}ret = access("fifo2",F_OK);if(ret == -1){// 管道文件不存在，需要创建出来printf("管道文件不存在，创建对应的管道\n");ret = mkfifo("fifo2",0664);if(ret == -1){perror("mkfifo");exit(-1);}}// 2、以只读的方式打开 fifo1int fdw = open("fifo1",O_WRONLY);if(fdw == -1){perror("open");exit(-1);}printf("打开fifo1成功，等待读取数据...\n");// 3、以只写的方式打开 fifo2int fdr = open("fifo2",O_RDONLY);if(fdr == -1){perror("open");exit(-1);}printf("打开fifo2成功，等待写入数据...\n");pid_t pid = fork();if(pid > 0){// 4、循环的写读数据char buf[128];while(1){memset(buf,0,128);// 获取标准输入的数据，不使用 scanf，因为会读取到换行就会结束fgets(buf,128,stdin);// 写数据ret = write(fdw,buf,strlen(buf));if(ret == -1){perror("write");exit(-1);}}close(fdw);wait(NULL);}else if(pid == 0){// 4、循环的写读数据char buf[128];while(1){// 读管道数据memset(buf,0,128);ret = read(fdr,buf,128);if(ret <= 0){perror("read");exit(-1);}printf("buf: %s\n",buf);}close(fdr);}return 0;
}

qykhhr@qykhhr:~/Linux/lesson24$ ./chatForkB
打开fifo1成功，等待读取数据...
打开fifo2成功，等待写入数据...
buf: 12323
buf: 2222buf: 2222buf: 3333buf: 444buf: 555232
32
343
32
121

10、内存映射

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

11、内存映射相关系统调用

#include <sys/mman.h>
void *mmap(void *addr,size_t length,int port, int flags, int fd, off_t offset);
int munmap(void *addr, size_t length);

使用内存映射区实现进程间通信

1、有关系的进程（父子进程）

• 还没有子进程的时候
  • 通过唯一的父进程，先创建内存映射区
• 有了内存映射区后，创建子进程
• 父子进程共享创建的内存映射区

2、没有关系的进程间通信

• 准备一个大小不是 0 的磁盘文件
• 进程1 通过磁盘文件创建内存映射区
  • 得到一个操作这块内存的指针
• 进程 2 通过磁盘文件创建内存映射区
  • 得到一个操作这块内存的指针
• 内存映射区通信

注意：内存映射区通信，是没有阻塞的

/*
#include <sys/mman.h>
void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);功能：将一个文件或者设备的数据映射到内存中参数：- void *addr：传入NULL，就会由内核决定映射的内存地址- size_t length：要映射的数据的长度，不能为0。建议使用文件的长度。会使用页的整数倍，不够会补充获取文件的长度：stat lseekint size = lseek(fd,0,SEEK_END);- int prot：对申请的内存映射区的操作权限PROT_EXEC  Pages may be executed.PROT_READ  Pages may be read.PROT_WRITE Pages may be written.PROT_NONE  Pages may not be accessed.要操作映射内存，必须要有读的权限PROT_READ、PROT_READ | PROT_WRITE- int flags：- MAP_SHARED：内存映射区的数据会自动和磁盘文件进行同步，进程间通信必须要设置这个选项- MAP_PRIVATE：不同步，内存映射区的数据改变了，对原来的文件不会修改，会重新创建一个新的文件（copy or write）- int fd：需要映射的那个文件的文件描述符- 通过 open 得到，open 的是一个磁盘文件- 注意：文件大小不能为 0，open 指定的权限不能和 prot 参数有冲突，prot 权限必须小于 open 权限prot：PROT_READ                 open：只读/读写prot：PROT_READ | PROT_WRITE    open：读写- off_t 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 <sys/fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/types.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(-1);}// 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, my is son!!!");}// 关闭内存映射区munmap(ptr,size); return 0;
}

qykhhr@qykhhr:~/Linux/lesson25$ ./mmap-parent-child-ipc 
read data: nihao a, my is son!!!

使用内存映射实现文件拷贝的功能

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

13、匿名映射

匿名映射：不需要文件实体进行内存映射

/*
匿名映射：不需要文件实体进行内存映射
*/
#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.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("open");exit(-1);}// 父子进程间通信pid_t pid = fork();if(pid > 0){// 向内存映射区中写入数据// 拷贝字符串 *ptr 到 buf 缓冲区，buf 的缓冲区要充足，要不然会产生段错误strcpy((char *)ptr,"hello world");// 回收子进程资源wait(NULL);}else if(pid == 0){// 因为内存映射是不会阻塞的，所以这里需要阻塞1s，等待父进程写入数据完成sleep(1);// 从内存映射区中读取数据// char buf[64];// strcpy(buf,(char *)str);// printf("read data: %s\n",buf);printf("%s\n",(char *)ptr);}// 释放内存映射区int ret = munmap(ptr, len);if(ret == -1){perror("munmap");exit(-1);}return 0;
}

qykhhr@qykhhr:~/Linux/lesson25$ gcc -o mmap-anon mmap-anon.c 
qykhhr@qykhhr:~/Linux/lesson25$ ./mmap-anon 
hello world

14、思考问题

如果对 mmap 的返回值(ptr)做++操作(ptr++)，munmap 是否能够成功？

对 ptr 进行ptr++;操作后，可以读取数据，但是 munmap(ptr,size); 错误（munmap: Invalid argument），需要传入操作前的 ptr 。

如果 open 时 O_RDONLY，mmap时 port 参数指定 PROT_READ | PROT_WRITE 会怎样？

错误，返回 MAP_FAILED（Permission denied）。open 函数中的权限建议和 port 参数的权限保持一致。

如果文件偏移量为 1000 会怎样？

偏移量必须是 4k 的整数倍，返回 MAP_FAILED。

mmap 什么情况下会调用失败？

第二个参数：length = 0

第三个参数：只指定了写权限

//…

可以 open 的时候 O_CREAT 一个新文件来创建映射区吗？

可以的，但是创建的文件的大小如果为0的话，肯定不行，需要映射文件到内存，length不能为0。

可以对新的文件进行扩展。

• lseek(fd,size,SEEK_END);
• truncate(“xxx.txt”,size);

mmap 后关闭文件描述符，对 mmap 映射有没有影响？

int fd = open("XXX",O_RDWR);
mmap(,,,,fd,0);
close(fd);

我们操作的是内存映射区的指针，内存映射区的指针还存在，创建映射区的fd被关闭，没有任何影响。

对 ptr 越界操作会怎样？

void *ptr = mmap(NULL,100,,,);

越界操作，操作的是非法内存，会发生段错误。

七、信号

1、信号的概念

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

发往进程的诸多信号，通常都是源于内核。引发内核为进程产生信号的各类事件如下：

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

使用信号的两个主要目的是：

• 让进程知道已经发生了一个特定的事情。
• 强迫进程执行它自己代码中的信号处理程序。

信号的特点：

• 简单
• 不能携带大量信息
• 满足某个特定条件才发送
• 优先级比较高

查看系统定义的信号列表： kill –l

前 31 个信号为常规信号，其余为实时信号。

qykhhr@qykhhr:~$ kill -l1) SIGHUP	 2) SIGINT	 3) SIGQUIT	 4) SIGILL	 5) SIGTRAP6) SIGABRT	 7) SIGBUS	 8) SIGFPE	 9) SIGKILL	10) SIGUSR1
11) SIGSEGV	12) SIGUSR2	13) SIGPIPE	14) SIGALRM	15) SIGTERM
16) SIGSTKFLT	17) SIGCHLD	18) SIGCONT	19) SIGSTOP	20) SIGTSTP
21) SIGTTIN	22) SIGTTOU	23) SIGURG	24) SIGXCPU	25) SIGXFSZ
26) SIGVTALRM	27) SIGPROF	28) SIGWINCH	29) SIGIO	30) SIGPWR
31) SIGSYS	34) SIGRTMIN	35) SIGRTMIN+1	36) SIGRTMIN+2	37) SIGRTMIN+3
38) SIGRTMIN+4	39) SIGRTMIN+5	40) SIGRTMIN+6	41) SIGRTMIN+7	42) SIGRTMIN+8
43) SIGRTMIN+9	44) SIGRTMIN+10	45) SIGRTMIN+11	46) SIGRTMIN+12	47) SIGRTMIN+13
48) SIGRTMIN+14	49) SIGRTMIN+15	50) SIGRTMAX-14	51) SIGRTMAX-13	52) SIGRTMAX-12
53) SIGRTMAX-11	54) SIGRTMAX-10	55) SIGRTMAX-9	56) SIGRTMAX-8	57) SIGRTMAX-7
58) SIGRTMAX-6	59) SIGRTMAX-5	60) SIGRTMAX-4	61) SIGRTMAX-3	62) SIGRTMAX-2
63) SIGRTMAX-1	64) SIGRTMAX

2、Linux 信号一览表

编号	信号名称	对应事件	默认动作
1	SIGHUP	用户退出shell时，由该shell启动的所有进程将收到这个信号	终止进程
2	SIGINT	当用户按下了<Ctrl+C>组合键时，用户终端向正在运行中的由该终端启动的程序发出此信号	终止进程
3	SIGQUIT	用户按下<Ctrl+\>组合键时产生该信号，用户终端向正在运行中的由该终端启动的程序发出此信号	终止进程
4	SIGILL	CPU检测到某进程执行了非法指令	终止进程并产生 core 文件
5	SIGTRAP	该信号由断点指令或其他 trap 指令产生	终止进程并产生 core 文件
6	SIGABRT	调用 abort 函数时产生该信号	终止进程并产生 core 文件
7	SIGBUS	非法访问内存地址，包括内存对齐错误	终止进程并产生 core 文件
8	SIGFPE	在发生致命的运算错误时发出。不仅包括浮点运算错误，还包括溢出及除数为0等所有的算法错误	终止进程并产生 core 文件
9	SIGKILL	无条件终止进程。该信号不能被忽略处理和阻塞	终止进程，可以杀死任何进程
10	SIGUSE1	用户定义的信号。即程序员可以在程序中定义并使用该信号	终止进程
11	SIGSEGV	指示进程进行了无效内存访问(段错误)	终止进程并产生 core 文件
12	SIGUSR2	另外一个用户自定义信号，程序员可以在程序中 定义并使用该信号	终止进程
13	SIGPIPE	Broken pipe向一个没有读端的管道写数据	终止进程
14	SIGALRM	定时器超时，超时的时间 由系统调用alarm设置	终止进程
15	SIGTERM	程序结束信号，与SIGKILL不同的是，该信号可以被阻塞和终止。通常用来要示程序正常退出。 执行shell命令Kill时，缺省产生这个信号	终止进程
16	SIGSTKFLT	Linux早期版本出现的信号，现仍保留向后兼容	终止进程
17	SIGCHLD	子进程结束时，父进程会收到这个信号	忽略这个信号
18	SIGCONT	如果进程已停止，则使其继续运行	继续/忽略
19	SIGSTOP	停止进程的执行。信号不能被忽略，处理和阻塞	为终止进程
20	SIGTSTP	停止终端交互进程的运行。按下<ctrl+z>组合键时发出这个信号	暂停进程
21	SIGTTIN	后台进程读终端控制台	暂停进程
22	SIGTTOU	该信号类似于SIGTTIN，在后台进程要向终端输出数据时发生	暂停进程
23	SIGURG	套接字上有紧急数据时，向当前正在运行的进程发出些信号，报告有紧急数据到达。如网络带外数据到达	忽略该信号
24	SIGXCPU	进程执行时间超过了分配给该进程的CPU时间，系统产生该信号并发送给该进程	终止进程
25	SIGXFSZ	超过文件的最大长度设置	终止进程
26	SIGVTALRM	虚拟时钟超时时产生该信号。类似于SIGALRM，但是该信号只计算该进程占用CPU的使用时间	终止进程
27	SGIPROF	类似于SIGVTALRM，它不公包括该进程占用CPU时间还包括执行系统调用时间	终止进程
28	SIGWINCH	窗口变化大小时发出	忽略该信号
29	SIGIO	此信号向进程指示发出了一个异步IO事件	忽略该信号
30	SIGPWR	关机	终止进程
31	SIGSYS	无效的系统调用	终止进程并产生 core 文件
34~64	SIGRTMIN ~ SIGRTMAX	LINUX的实时信号，它们没有固定的含义（可以由用户自定义）	终止进程

3、信号的5种默认处理动作

查看信号的详细信息：man 7 signal

信号的 5 种默认处理动作

• Term：终止进程
• Ign：当前进程忽略掉这个信号
• Core：终止进程，并生成一个Core文件
• Stop：暂停当前进程
• Cont：继续执行当前被暂停的进程

信号的几种状态：产生、未决、速达

SIGKILL 和 SIGSTOP 信号不能被捕捉、阻塞或者忽略，只能执行默认动作。

Core：终止进程，并生成一个Core文件

core.c

#include <stdio.h>
#include <string.h>int main()
{char *buf;// char buf[64];strcpy(buf,"hello");return 0;
}

首先需要设置core file size ，通过ulimit -c 1024可以设置 core 文件大小，默认为0，不存储数据。

qykhhr@qykhhr:~/Linux/lesson26$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 15435
max locked memory       (kbytes, -l) 65536
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 15435
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited
qykhhr@qykhhr:~/Linux/lesson26$ ulimit -c 1024
qykhhr@qykhhr:~/Linux/lesson26$ ulimit -a
core file size          (blocks, -c) 1024
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 15435
max locked memory       (kbytes, -l) 65536
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 15435
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

使用调试模式生成可执行程序，执行程序发生段错误后会默认生成文件名为core的core文件，再使用 gdb a.out调试程序，使用core-file core即可调试生成的 core 文件。

qykhhr@qykhhr:~/Linux/lesson26$ gcc core.c -g
qykhhr@qykhhr:~/Linux/lesson26$ ./a.out 
段错误 (核心已转储)
qykhhr@qykhhr:~/Linux/lesson26$ gdb a.out 
GNU gdb (Ubuntu 8.1.1-0ubuntu1) 8.1.1
Copyright (C) 2018 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.
For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from a.out...done.
(gdb) core-file core
[New LWP 7310]
Core was generated by `./a.out'.
Program terminated with signal SIGSEGV, Segmentation fault.
#0  0x00005618a2abf602 in main () at core.c:8
8	    strcpy(buf,"hello");
(gdb) 

4、信号相关的函数

int kill(pid_t pid, int sig);

#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);

• 作用：给任何进程或者进程组 pid，发送任何的信号 sig
• 参数：
  • pid：
    • > 0 ：将信号发送给指定的进程
    • = 0 ：将信号发送给当前的进程组
    • = -1：将信号发送给每一个有权限接受这个信号的进程
    • < -1：这个pid某个进程组的id取反（12345 取反后为 -12345）
  • sig：需要发送的信号的编号或者是宏值

返回值：成功返回0，失败返回-1
kill(getppid(),9); 给父进程发送一个终止信号
kill(getpid(),9); 给当前进程发送一个终止信号

/*
#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);作用：给任何进程或者进程组 pid，发送任何的信号 sig参数：- pid：> 0 ：将信号发送给指定的进程= 0 ：将信号发送给当前的进程组= -1：将信号发送给每一个有权限接受这个信号的进程< -1：这个pid某个进程组的id取反（12345 取反后为 -12345）- sig：需要发送的信号的编号或者是宏值返回值：成功返回0，失败返回-1kill(getppid(),9); 给父进程发送一个终止信号kill(getpid(),9); 给当前进程发送一个终止信号#include <signal.h>
int raise(int sig);作用：给当前进程发送信号参数：sig：要发送的信号返回值：成功返回0，失败返回非0#include <stdlib.h>
void abort(void);   作用：发送 SIGABRT 信号给当前的进程，杀死当前进程kill(getpid(),SIGABRT);
*/
#include <sys/types.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>int main()
{pid_t pid = fork();if(pid == 0){// 子进程for(int 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");int ret = kill(pid,SIGINT);if(ret == -1){ perror("kill");exit(-1);}}return 0;
}

qykhhr@qykhhr:~/Linux/lesson26$ ./kill 
parent process
child process
child process
kill child process now

int raise(int sig);

#include <signal.h>
int raise(int sig);
作用：给当前进程发送信号
参数：sig：要发送的信号
返回值：成功返回0，失败返回非0

/*
给当前进程发送信号
raise(pid,signal);
*/
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <signal.h>int main()
{int num = 0;while(1){printf("hello,I am is main func, num = %d\n",num++);sleep(1);if(num == 4){int ret = raise(SIGKILL);if(ret == -1){perror("raise");return -1;}}}return 0;
}

qykhhr@qykhhr:~/Linux2$ gcc 32-raise.c -o 32-raise
qykhhr@qykhhr:~/Linux2$ ./32-raise 
hello,I am is main func, num = 0
hello,I am is main func, num = 1
hello,I am is main func, num = 2
hello,I am is main func, num = 3
已杀死

void abort(void);

#include <stdlib.h>
void abort(void);

作用：发送 SIGABRT 信号给当前的进程，杀死当前进程
kill(getpid(),SIGABRT);

/*
发送 SIGABORT 信号给当前的进程， 杀死当前进程
*/
#include <stdio.h>
#include <stdlib.h>
int main()
{int num = 0;while (1){printf("Hello,I am main func,num = %d\n",num++);if(num == 4){abort();}}return 0;
}

qykhhr@qykhhr:~/Linux2$ gcc 33-abort.c -o 33-abort
qykhhr@qykhhr:~/Linux2$ ./33-abort 
Hello,I am main func,num = 0
Hello,I am main func,num = 1
Hello,I am main func,num = 2
Hello,I am main func,num = 3
已放弃 (核心已转储)

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
过了 1s
alarm(5); --> 返回 9
alarm(100) --> 该函数是不阻塞的

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

qykhhr@qykhhr:~/Linux/lesson26$ ./alarm 
seconds = 0
seconds = 8
闹钟

1秒钟电脑能数多少个数

实际的时间 = 内核时间 + 用户时间（代码一行一行执行的时间） + 消耗的时间
进行文件IO操作的时候比较浪费时间
定时器，与进程的状态无关（自然定时法），无论进程处于什么状态，alarm都会计时

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

输出到终端上

//......
640188
640189
640190
640191
640192
640193
640194
闹钟

输出到文件中

./alarm >> a.txt

//......
22432732

int setitimer(int which, const struct itimerval *new_value, 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：真实时间，时间到达，发送 SIGALARMITIMER_VIRTUAL：用户时间，发送 SIGVTALRMITIMER_PROF：以该进程在用户态和内核态下所消耗的时间来计算，时间到达，发送 SIGPROF 信号- new_value：设置定时器的属性struct itimerval { // 定时器的结构体struct timeval it_interval; // 每个阶段的时间，间隔时间struct timeval it_value; // 延迟多长时间执行定时器};struct timeval { // 时间的结构体time_t      tv_sec; // 秒数suseconds_t tv_usec; // 微妙};过 10s（it_value） 后，每隔2s（it_interval）定时一次- old_value：记录上一次定时的时间参数，一般不使用，指定 NULL 即可返回值：成功返回0，失败返回 -1
*/
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{// 过3s以后，每隔2s执行一次struct itimerval new_value;// 设置间隔的时间new_value.it_interval.tv_sec = 2;new_value.it_interval.tv_usec = 0;// 设置延迟的时间new_value.it_value.tv_sec = 3;new_value.it_value.tv_usec = 0;// 非阻塞int ret = setitimer(ITIMER_REAL,&new_value,NULL);if(ret == -1){perror("setitimer");exit(-1);}// 让程序不要自己停止getchar();return 0;
}

qykhhr@qykhhr:~/Linux/lesson26$ ./setitimer 
闹钟

5、信号捕捉函数

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("xxxxx\n");
}
int main()
{// 注册信号捕捉// 忽略SIGALRM信号，程序会一直运行// signal(SIGALRM,SIG_IGN);// 默认处理，程序会停止// signal(SIGALRM,SIG_DFL);// 回调函数，void (*sighandler_t)(int);函数指针，int 类型参数表示捕捉到的信号的值signal(SIGALRM, myAlarm);// 过3s以后，每隔2s执行一次struct itimerval new_value;// 设置间隔的时间new_value.it_interval.tv_sec = 2;new_value.it_interval.tv_usec = 0;// 设置延迟的时间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(-1);}// 让程序不要自己停止getchar();return 0;
}

qykhhr@qykhhr:~/Linux/lesson26$ ./signal 
定时器开始了.....
捕捉到的信号的编号是：14
xxxxx
捕捉到的信号的编号是：14
xxxxx
捕捉到的信号的编号是：14
xxxxx
//......

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：上一次对信号捕捉相关的设置，一般不使用，传递 NULLstruct sigaction {// 函数指针，指向的函数就是信号捕捉到之后的处理函数void     (*sa_handler)(int); // 不常用void     (*sa_sigaction)(int, siginfo_t *, void *);// 临时阻塞信号集，在信号捕捉函数执行过程中，临时阻塞某些信号sigset_t   sa_mask;// 使用哪一个信号处理对捕捉到的信号进行处理// 这个值可以是0，表示使用sa_handler，也可以是 SA_SIGINFO，表示使用 sa_sigactionint        sa_flags;// 被废弃了，指定 NULL 即可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("xxxxx\n");
}
int main()
{// 注册信号捕捉struct sigaction act;act.sa_flags = 0;act.sa_handler = myAlarm;sigemptyset(&act.sa_mask);// 清空临时阻塞信号集sigaction(SIGALRM,&act,NULL);// 过3s以后，每隔2s执行一次struct itimerval new_value;// 设置间隔的时间new_value.it_interval.tv_sec = 2;new_value.it_interval.tv_usec = 0;// 设置延迟的时间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(-1);}// 让程序不要自己停止while(1);return 0;
}

qykhhr@qykhhr:~/Linux/lesson26$ ./sigaction 
定时器开始了.....
捕捉到的信号的编号是：14
xxxxx
捕捉到的信号的编号是：14
xxxxx
捕捉到的信号的编号是：14
xxxxx
//......

6、信号集

许多信号相关的系统调用都需要能表示一组不同的信号，多个信号可使用一个称之为信号集的数据结构来表示，其系统数据类型为 sigset_t。

在 PCB 中有两个非常重要的信号集。一个称之为 “阻塞信号集” ，另一个称之为“未决信号集” 。这两个信号集都是内核使用位图机制来实现的。但操作系统不允许我们直接对这两个信号集进行位操作。而需自定义另外一个集合，借助信号集操作函数来对 PCB 中的这两个信号集进行修改。

信号的 “未决” 是一种状态，指的是从信号的产生到信号被处理前的这一段时间。

信号的 “阻塞” 是一个开关动作，指的是阻止信号被处理，但不是阻止信号产生。

信号的阻塞就是让系统暂时保留信号留待以后发送。由于另外有办法让系统忽略信号，所以一般情况下信号的阻塞只是暂时的，只是为了防止信号打断敏感的操作。

7、阻塞信号集和未决信号集

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

2.信号产生但是没有被处理 （未决）

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

3.这个未决状态的信号，需要被处理，处理之前需要和另一个信号集（阻塞信号集），进行比较

• 阻塞信号集默认不阻塞任何的信号
• 如果想要阻塞某些信号需要用户调用系统的API

4.在处理的时候和阻塞信号集中的标志位进行查询，看是不是对该信号设置阻塞了

• 如果没有阻塞，这个信号就被处理
• 如果阻塞了，这个信号就继续处于未决状态，直到阻塞解除，这个信号就被处理

8、信号集相关的函数

int sigemptyset(sigset_t *set);

功能：清空临时阻塞信号集中的数据，将信号集中的所有标志位置为 0
参数：set，传出参数，需要操作的信号集
返回值：成功返回0，失败返回-1int sigfillset(sigset_t *set);

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：调用失败

/*
以下信号集相关的函数都是对自定义的信号集进行操作int sigemptyset(sigset_t *set);功能：清空信号集中的数据，将信号集中的所有标志位置为 0参数：set，传出参数，需要操作的信号集返回值：成功返回0，失败返回-1int 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 是否在信号集 set 里面ret = sigismember(&set,SIGINT);if(ret == -1){perror("sigismember");}else if(ret == 0){printf("SIGINT 不阻塞\n");}else if(ret == 1){printf("SIGINT 阻塞\n");}// 从信号集中删除一个信号sigdelset(&set,SIGQUIT);// 判断 SIGQUIT 是否在信号集 set 里面ret = sigismember(&set,SIGQUIT);if(ret == 0){printf("SIGQUIT 不阻塞\n");}else if(ret == 1){printf("SIGQUIT 阻塞\n");}// 判断return 0;
}

qykhhr@qykhhr:~/Linux/lesson26$ ./sigset 
SIGINT 不阻塞
SIGINT 阻塞
SIGQUIT 不阻塞

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，传出参数，保存的是内核中的未决信号集中的角色

/*
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);功能：将自定义信号集中的数据设置到内核中（设置阻塞信号集、解除阻塞、替换）参数：how：如何对内核阻塞信号集进行处理SIG_BLOCK：将用户设置的阻塞信号集添加到内核中，内核中原来的数据不变假设内核中默认的阻塞信号是 mask，mask | setSIG_UNBLOCK：根据用户设置的数据，对内核中的数据进行解除阻塞mask &= ~setSIG_SETMASK：覆盖内核中原来的值set：已经初始化好的用户自定义的信号集oldset：保存设置之前的内核中的阻塞信号集的状态，可以是 NULL返回值：成功返回0，失败返回-1，并设置错误号：EFAULT、EINVALint 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){// 1：signum被阻塞// 未决信号printf("1");}else if(sigismember(&pendingset,i) == 0){// // 1：signum不阻塞printf("0");}else {perror("sigismember");exit(-1);}}printf("\n");sleep(1);if(num >= 10){// 解决阻塞，发送的 SIGINT、SIGQUIT 信号就会让当前进程退出sigprocmask(SIG_UNBLOCK,&set,NULL);}}return 0;
}

qykhhr@qykhhr:~/Linux/lesson26$ ./sigprocmask 
0000000000000000000000000000000
0000000000000000000000000000000
^C0100000000000000000000000000000
^\0110000000000000000000000000000
0110000000000000000000000000000
0110000000000000000000000000000
0110000000000000000000000000000
0110000000000000000000000000000
0110000000000000000000000000000
0110000000000000000000000000000

9、内核实现信号捕捉的过程

10、SIGCHLD 信号

SIGCHLD 信号产生的条件

• 子进程终止时
• 子进程接收到 SIGSTOP 信号停止时
• 子进程处在停止态，接收到 SIGCONT 后唤醒时

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

使用 SIGCHLD 信号解决僵尸进程问题

/*
SIGCHLD信号产生的3个条件：1、子进程结束了2、子进程暂停了3、子进程继续运行都会给父进程发送该信号，父进程默认忽略该信号
使用 SIGCHLD 信号解决僵尸进程问题
*/#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <signal.h>
#include <wait.h>void myFun(int num)
{printf("接收到信号：%d\n",num);// 回收子进程的 PCB 资源// 一次只能处理一个信号，多余信号将会丢弃，所以会存在部分僵尸进程没有被回收资源// wait(NULL); 一次只能回收一个子进程// int ret = wait(NULL);// printf("%d process is die\n",ret);// 循环回收可以回收所以子进程资源，但是需要父进程一直在这里进行回收工作，也不现实// int ret = -1;// while (1)// {//     ret = wait(NULL);//     printf("%d process is die\n",ret);// }// 调用waitpid 采用非阻塞回收资源while(1){// -1:meaning wait for any child process(等待所有子进程)int ret = waitpid(-1,NULL,WNOHANG);if(ret > 0){printf("%d process is die\n",ret);}else if(ret == 0){// 如果设置了 WNOHANG，并且还有子进程没有改变状态，返回0// 还有子进程等待回收continue;}else if(ret == -1){// 没有子进程了break;}}
}
int main()
{// 提前设置后阻塞信号集，阻塞 SIGCHLD，因为有可能子进程很快结束，父进程还没有注册完信号捕捉sigset_t set;sigemptyset(&set);sigaddset(&set,SIGCHLD);sigprocmask(SIG_BLOCK,&set,NULL);// 创建一些子进程pid_t pid;for(int i = 0; i < 20; i++){pid = fork();if(pid == 0){// 子进程退出循环，不参与创建进程的过程break;}}if(pid > 0){// 父进程 // 捕捉子进程死亡时发送的 SIGCHLD 信号struct sigaction act;act.sa_flags = 0;act.sa_handler = myFun;// 清空默认阻塞信号集sigemptyset(&act.sa_mask);sigaction(SIGCHLD,&act,NULL);// 捕捉到信号后，不要再阻塞信号，释放信号，让信号内核收到信号// 只需要捕捉一次信号调用 myFun ，通过 waitpid(-1,NULL,WNOHANG) 来回收所有子进程即可sigprocmask(SIG_UNBLOCK,&set,NULL);while(1){printf("parent process pid:%d\n",getpid());sleep(2);}}else if (pid == 0){// 子进程，打印一句话就结束进程，此时父进程没有结束（子进程由僵尸进程成为孤儿进程，会由1号进程进行回收资源）也没有回收子进程资源，导致子进程成为僵尸进程。printf("This is child process!,pid = %d, ppid = %d\n",getpid(),getppid());}return 0;
}

qykhhr@qykhhr:~/Linux/lesson26$ ./sigchld 
This is child process!,pid = 4667, ppid = 4666
This is child process!,pid = 4668, ppid = 4666
This is child process!,pid = 4670, ppid = 4666
This is child process!,pid = 4671, ppid = 4666
This is child process!,pid = 4669, ppid = 4666
This is child process!,pid = 4676, ppid = 4666
This is child process!,pid = 4672, ppid = 4666
This is child process!,pid = 4677, ppid = 4666
This is child process!,pid = 4675, ppid = 4666
This is child process!,pid = 4680, ppid = 4666
This is child process!,pid = 4673, ppid = 4666
This is child process!,pid = 4681, ppid = 4666
This is child process!,pid = 4679, ppid = 4666
This is child process!,pid = 4678, ppid = 4666
This is child process!,pid = 4674, ppid = 4666
This is child process!,pid = 4683, ppid = 4666
This is child process!,pid = 4684, ppid = 4666
This is child process!,pid = 4685, ppid = 4666
This is child process!,pid = 4682, ppid = 4666
This is child process!,pid = 4686, ppid = 4666
接收到信号：17
4667 process is die
4668 process is die
4669 process is die
4670 process is die
4671 process is die
4672 process is die
4673 process is die
4674 process is die
4675 process is die
4676 process is die
4677 process is die
4678 process is die
4679 process is die
4680 process is die
4681 process is die
4682 process is die
4683 process is die
4684 process is die
4685 process is die
4686 process is die
parent process pid = 4666
parent process pid = 4666
......

八、共享内存

1、共享内存

共享内存允许两个或者多个进程共享物理内存的同一块区域（通常被称为段）。由于一个共享内存段会成为一个进程用户空间的一部分，因此这种 IPC 机制无需内核介入。所有需要做的就是让一个进程将数据复制进共享内存中，并且这部分数据会对其他所有共享同一个段的进程可用。

与管道等要求发送进程将数据从用户空间的缓冲区复制进内核内存和接收进程将数据从内核内存复制进用户空间的缓冲区的做法相比，这种 IPC 技术的速度更快。

2、共享内存使用步骤

调用 shmget() 创建一个新共享内存段或取得一个既有共享内存段的标识符（即由其他进程创建的共享内存段）。这个调用将返回后续调用中需要用到的共享内存标识符。

使用 shmat() 来附上共享内存段，即使该段成为调用进程的虚拟内存的一部分。

此刻在程序中可以像对待其他可用内存那样对待这个共享内存段。为引用这块共享内存，程序需要使用由 shmat() 调用返回的 addr 值，它是一个指向进程的虚拟地址空间中该共享内存段的起点的指针。

调用 shmdt() 来分离共享内存段。在这个调用之后，进程就无法再引用这块共享内存了。这一步是可选的，并且在进程终止时会自动完成这一步。

调用 shmctl() 来删除共享内存段。只有当当前所有附加内存段的进程都与之分离之后内存段才会销毁。只有一个进程需要执行这一步。

3、共享内存操作函数

int shmget(key_t key, size_t size, int shmflg);
void *shmat(int shmid, const void *shmaddr, int shmflg);
int shmdt(const void *shmaddr);
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
key_t ftok(const char *pathname, int proj_id);

共享内存相关的函数
#include <sys/ipc.h>
#include <sys/shm.h>int shmget(key_t key, size_t size, int shmflg);- 功能：创建一个新的共享内存段，或者获取一个既有的共享内存段的标识。新创建的内存段中的数据都会被初始化为0- 参数：- key : key_t类型是一个整型，通过这个找到或者创建一个共享内存。一般使用16进制表示，非0值- size: 共享内存的大小- shmflg: 属性- 访问权限- 附加属性：创建/判断共享内存是不是存在- 创建：IPC_CREAT- 判断共享内存是否存在： IPC_EXCL , 需要和IPC_CREAT一起使用IPC_CREAT | IPC_EXCL | 0664- 返回值：失败：-1 并设置错误号成功：>0 返回共享内存的引用的ID，后面操作共享内存都是通过这个值。void *shmat(int shmid, const void *shmaddr, int shmflg);- 功能：和当前的进程进行关联- 参数：- shmid : 共享内存的标识（ID）,由shmget返回值获取- shmaddr: 申请的共享内存的起始地址，指定NULL，内核指定- shmflg : 对共享内存的操作- 读 ： SHM_RDONLY, 必须要有读权限- 读写： 0- 返回值：成功：返回共享内存的首（起始）地址。  失败(void *) -1int shmdt(const void *shmaddr);- 功能：解除当前进程和共享内存的关联- 参数：shmaddr：共享内存的首地址- 返回值：成功 0， 失败 -1int shmctl(int shmid, int cmd, struct shmid_ds *buf);- 功能：对共享内存进行操作。删除共享内存，共享内存要删除才会消失，创建共享内存的进行被销毁了对共享内存是没有任何影响。- 参数：- shmid: 共享内存的ID- cmd : 要做的操作- IPC_STAT : 获取共享内存的当前的状态- IPC_SET : 设置共享内存的状态- IPC_RMID: 标记共享内存被销毁- buf：需要设置或者获取的共享内存的属性信息- IPC_STAT : buf存储数据- IPC_SET : buf中需要初始化数据，设置到内核中- IPC_RMID : 没有用，NULLkey_t ftok(const char *pathname, int proj_id);- 功能：根据指定的路径名，和int值，生成一个共享内存的key- 参数：- pathname:指定一个存在的路径/home/nowcoder/Linux/a.txt/ - proj_id: int类型的值，但是这系统调用只会使用其中的1个字节范围 ： 0-255  一般指定一个字符 'a'问题1：操作系统如何知道一块共享内存被多少个进程关联？- 共享内存维护了一个结构体struct shmid_ds 这个结构体中有一个成员 shm_nattch- shm_nattach 记录了关联的进程个数问题2：可不可以对共享内存进行多次删除 shmctl- 可以的- 因为shmctl 标记删除共享内存，不是直接删除- 什么时候真正删除呢?当和共享内存关联的进程数为0的时候，就真正被删除- 当共享内存的key为0的时候，表示共享内存被标记删除了如果一个进程和共享内存取消关联，那么这个进程就不能继续操作这个共享内存。也不能进行关联。共享内存和内存映射的区别1.共享内存可以直接创建，内存映射需要磁盘文件（匿名映射除外）2.共享内存效果更高3.内存所有的进程操作的是同一块共享内存。内存映射，每个进程在自己的虚拟地址空间中有一个独立的内存。4.数据安全- 进程突然退出共享内存还存在内存映射区消失- 运行进程的电脑死机，宕机了数据存在在共享内存中，没有了内存映射区的数据 ，由于磁盘文件中的数据还在，所以内存映射区的数据还存在。5.生命周期- 内存映射区：进程退出，内存映射区销毁- 共享内存：进程退出，共享内存还在，标记删除（所有的关联的进程数为0），或者关机如果一个进程退出，会自动和共享内存进行取消关联。

共享内存实现进程间通信

write_shm.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include<string.h>
int main()
{// 1、创建一个共享内存int shmid = shmget(100,4096,IPC_CREAT | 0664);printf("shmid = %d\n",shmid);// 2、和当前进程进行关联void *ptr = shmat(shmid,NULL,0);// 3、写数据char *str = "helloworld";memcpy(ptr,str,strlen(str) + 1);printf("按任意键继续...\n");getchar();// 4、解除关联shmdt(ptr);// 5、删除共享内存shmctl(shmid,IPC_RMID,NULL);return 0;
}

qykhhr@qykhhr:~/Linux/lesson27$ ./write 
shmid = 33
按任意键继续...

read_shm.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include<string.h>
int main()
{// 1、创建一个共享内存int shmid = shmget(100,0,IPC_CREAT);printf("shmid = %d\n",shmid);// 2、和当前进程进行关联void *ptr = shmat(shmid,NULL,0);// 3、读数据printf("%s\n",(char *)ptr);printf("按任意键继续...\n");getchar();// 4、解除关联shmdt(ptr);// 5、删除共享内存shmctl(shmid,IPC_RMID,NULL);return 0;
}

qykhhr@qykhhr:~/Linux/lesson27$ ./read 
shmid = 33
helloworld
按任意键继续...

4、共享内存操作命令

ipcs 用法

ipcs -a // 打印当前系统中所有的进程间通信方式的信息
ipcs -m // 打印出使用共享内存进行进程间通信的信息
ipcs -q // 打印出使用消息队列进行进程间通信的信息
ipcs -s // 打印出使用信号进行进程间通信的信息

ipcrm 用法

ipcrm -M shmkey // 移除用shmkey创建的共享内存段
ipcrm -m shmid // 移除用shmid标识的共享内存段
ipcrm -Q msgkey // 移除用msqkey创建的消息队列
ipcrm -q msqid // 移除用msqid标识的消息队列
ipcrm -S semkey // 移除用semkey创建的信号
ipcrm -s semid // 移除用semid标识的信号

九、守护进程

1、终端

在 UNIX 系统中，用户通过终端登录系统后得到一个 shell 进程，这个终端成为 shell 进程的控制终端（Controlling Terminal），进程中，控制终端是保存在 PCB 中的信息，而 fork() 会复制 PCB 中的信息，因此由 shell 进程启动的其它进程的控制终端也是这个终端。

默认情况下（没有重定向），每个进程的标准输入、标准输出和标准错误输出都指向控制终端，进程从标准输入读也就是读用户的键盘输入，进程往标准输出或标准错误输出写也就是输出到显示器上。

在控制终端输入一些特殊的控制键可以给前台进程发信号，例如 Ctrl + C 会产生 SIGINT 信号， Ctrl + \ 会产生 SIGQUIT 信号。

echo $$可以查看当前终端的pid

tty查看设备终端

2、进程组

进程组和会话在进程之间形成了一种两级层次关系：进程组是一组相关进程的集合，会话是一组相关进程组的集合。进程组和会话是为支持 shell 作业控制而定义的抽象概念，用户通过 shell 能够交互式地在前台或后台运行命令。

进行组由一个或多个共享同一进程组标识符（PGID）的进程组成。一个进程组拥有一个进程组首进程，该进程是创建该组的进程，其进程 ID 为该进程组的 ID，新进程会继承其父进程所属的进程组 ID。

进程组拥有一个生命周期，其开始时间为首进程创建组的时刻，结束时间为最后一个成员进程退出组的时刻。一个进程可能会因为终止而退出进程组，也可能会因为加入了另外一个进程组而退出进程组。进程组首进程无需是最后一个离开进程组的成员。

3、会话

会话是一组进程组的集合。会话首进程是创建该新会话的进程，其进程 ID 会成为会话 ID。新进程会继承其父进程的会话 ID。

一个会话中的所有进程共享单个控制终端。控制终端会在会话首进程首次打开一个终端设备时被建立。一个终端最多可能会成为一个会话的控制终端。

在任一时刻，会话中的其中一个进程组会成为终端的前台进程组，其他进程组会成为后台进程组。只有前台进程组中的进程才能从控制终端中读取输入。当用户在控制终端中输入终端字符生成信号后，该信号会被发送到前台进程组中的所有成员。

当控制终端的连接建立起来之后，会话首进程会成为该终端的控制进程。

4、进程组、会话、控制终端之间的关系

• find / 2 > /dev/null | wc -l &
  • &：在后台运行这个程序
• sort < longlist | uniq -c

5、进程组、会话操作函数

pid_t getpgrp(void);
获取进程组id

pid_t getpgid(pid_t pid);
获取指定的进程的进程组id

int setpgid(pid_t pid, pid_t pgid);
设置进程组id

pid_t getsid(pid_t pid);
获取指定进程的会话id

pid_t setsid(void);
设置当前会话的id

6、守护进程

守护进程（Daemon Process），也就是通常说的 Daemon 进程（精灵进程），是Linux 中的后台服务进程。它是一个生存期较长的进程，通常独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。一般采用以 d 结尾的名字。

守护进程具备下列特征：

• 生命周期很长，守护进程会在系统启动的时候被创建并一直运行直至系统被关闭。
• 它在后台运行并且不拥有控制终端。没有控制终端确保了内核永远不会为守护进程自动生成任何控制信号以及终端相关的信号（如 SIGINT、 SIGQUIT）。
• Linux 的大多数服务器就是用守护进程实现的。比如， Internet 服务器 inetd，Web 服务器 httpd 等。

7、守护进程的创建步骤

1. 执行一个 fork()，之后父进程退出，子进程继续执行。
2. 子进程调用 setsid() 开启一个新会话。
3. 清除进程的 umask 以确保当守护进程创建文件和目录时拥有所需的权限。
4. 修改进程的当前工作目录，通常会改为根目录（/）。
5. 关闭守护进程从其父进程继承而来的所有打开着的文件描述符。
6. 在关闭了文件描述符0、 1、 2之后，守护进程通常会打开/dev/null 并使用dup2()，使所有这些描述符指向这个设备（这个 null 会忽略所有输入输出信息）。
7. 核心业务逻辑

/*
写一个守护进程，每隔2s获取一下系统时间，将这个时间写入到磁盘文件中
*/
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <signal.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
void work(int num)
{// 捕捉到信号之后，获取系统时间，写入磁盘文件time_t tm = time(NULL);struct tm* loc = localtime(&tm);// char buf[1024];// sprintf(buf,"%d-%d-%d %d:%d:%d\n",loc->tm_year,loc->tm_mon,loc->tm_mday,loc->tm_hour,loc->tm_min,loc->tm_sec);// printf("%s\n",buf);char *str = asctime(loc);int fd = open("time.txt",O_CREAT | O_RDWR | O_APPEND,0664);write(fd,str,strlen(str));
}
int main()
{// 1、创建子进程，退出父进程，在子进程中操作，防止两个进程组id相同，发生冲突pid_t pid = fork();if(pid > 0){// 父进程退出exit(0);}// 2、将子进程重新创建要给会话setsid();// 3、设置掩码umask(022);// 4、更改工作目录chdir("/home/qykhhr");// 5、关闭，重定向文件描述符，重定向到 null 设备上，会丢弃所有数据int fd = open("/dev/null",O_RDWR);dup2(fd,STDIN_FILENO);dup2(fd,STDOUT_FILENO);dup2(fd,STDERR_FILENO);// 6、业务逻辑// 捕捉定时信号struct sigaction act;act.sa_flags = 0;act.sa_handler = work;sigemptyset(&act.sa_mask);sigaction(SIGALRM,&act,NULL);// 创建定时器struct itimerval val;val.it_value.tv_sec = 2;val.it_value.tv_usec = 0;val.it_interval.tv_sec = 2;val.it_interval.tv_usec = 0;setitimer(ITIMER_REAL,&val,NULL);// 不让进程结束while(1){}return 0;
}