1、程序概述

1.1 程序

程序是包含一系列信息的文件（占用磁盘，不占用内存、CPU），这些信息描述了如何在运行时创建一个进程：

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

1.2 进程

进程是正在运行的程序的实例（占用内存、CPU资源）。是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。

可以用一个程序来创建多个进程，进程是由内核定义的抽象实体，并为该实体分配用以执行程序的各项系统资源。

从内核的角度看，进程由用户内存空间和一系列内核数据结构组成，其中用户内存空间包含了程序代码及代码所使用的变量，而内核数据结构则用于维护进程状态信息。记录在内核数据结构中的信息包括许多与进程相关的标识号（IDs）、虚拟内存表、打开文件的描述符表、信号传递及处理的有关信息、进程资源使用及限制、当前工作目录和大量的其他信息。

1.3 单道、多道程序设计

单道程序，即在计算机内存中只允许一个的程序运行。

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

  • 对于一个单 CPU 系统来说，程序同时处于运行状态只是一种宏观上的概念，他们虽然都已经开始运行，但就微观而言，任意时刻，CPU 上运行的程序只有一个（穿插运行、非同时）。

  • 在多道程序设计模型中，多个进程轮流使用 CPU。而当下常见 CPU 为纳秒级，1秒可以执行大约 10 亿条指令。由于人眼的反应速度是毫秒级，所以看似同时在运行。

1.4 时间片

时间片（timeslice）又称为“量子（quantum）”或“处理器片（processor slice）”是操作系统分配给每个正在运行的进程微观上的一段 CPU 时间。

事实上，虽然一台计算机通常可能有多个 CPU，但是同一个 CPU 永远不可能真正地同时运行多个任务。在只考虑一个 CPU 的情况下，这些进程“看起来像”同时运行的，实则是轮番穿插地运行，由于时间片通常很短（在 Linux 上为 5ms－800ms），用户不会感觉到。

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

1.5 并行和并发

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

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


1.6 进程控制块（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、进程状态转换

2.1 进程的状态

进程状态反映进程执行过程的变化。这些状态随着进程的执行和外界条件的变化而转换。

在三态模型中，进程状态分为三个基本状态，即就绪态，运行态，阻塞态。

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

在五态模型中，进程分为新建态、就绪态，运行态，阻塞态，终止态。

  • 新建态：进程刚被创建时的状态，尚未进入就绪队列。
    创建步骤包括：申请空白的 PCB，向 PCB 中填写一些控制和管理信息，系统向进程分配运行时所需的资源。
  • 终止态：进程完成任务到达正常结束点，或出现无法克服的错误而异常终止，或被操作系统及有终止权的进程所终止时所处的状态。进入终止态的进程以后不再执行，但依然保留在操作系统中等待善后。一旦其他进程完成了对终止态进程的信息抽取之后，操作系统将删除该进程。

2.2 进程相关命令

  • ps aux / ps 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 根据进程名杀死进程

2.3 进程号和相关函数

每个进程都由进程号来标识，其类型为 pid_t（整型），进程号的范围：0～32767。

进程号总是唯一的，但可以重用。当一个进程终止后，其进程号就可以再次使用。

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

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

◼ 进程号和进程组相关函数：
pid_t getpid(void);// 当前进程的进程ID
pid_t getppid(void); // 父进程ID
pid_t getpgid(pid_t pid); // 进程所在进程组ID

3、进程操作

系统允许一个进程创建新进程（使用的内存空间不一样），新进程即为子进程，子进程还可以创建新的子进程，形成进程树结构模型。

3.1 fork()

#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);返回值：-  成功：子进程中返回 0，父进程中返回子进程 ID-  失败：返回 -1失败的两个主要原因：1. 当前系统的**进程数**已经达到了系统规定的上限，这时 errno 的值被设置为 EAGAIN2. 系统**内存**不足，这时 errno 的值被设置为 ENOMEM

父子进程之间的关系：

区别：

  • fork() 函数的返回值不同
    父进程中: >0 返回的子进程的ID
    子进程中: =0
  • pcb 中的一些数据
    当前的进程的id: pid
    当前的进程的父进程的id: ppid
    信号集
  • 阻塞信号集初始化为空集(译者注：原文此处不明确，译文根据fork函数手册页稍做修改)
  • 不继承由timer_create函数创建的计时器
  • 不继承异步输入和输出
  • 不继承父进程设置的锁（因为如果是排他锁，被继承的话就矛盾了）

子进程继承资源：（刚被创建出来，还没有执行任何的写数据的操作）

  • 代码和数据：代码是共享的，不可更改；数据等需要变动时发生写时拷贝
  • 进程控制块：凡是进程都会有，子进程的PCB以父进程为模板
  • 地址空间：子进程也会有一份，和父进程一样
  • 页表：子进程也会有一份，数据发生变化时，由于发生了写时拷贝，映射到物理内存的地址会变化
  • 用户区的数据
  • 文件描述符表fd（存储在内核区PCB中）
  • 进程上下文
  • 进程堆栈
  • 内存信息
  • 打开的文件描述符
  • 信号控制设置
  • 进程优先级、进程组号
  • 当前工作目录
  • 根目录
  • 资源限制
  • 控制终端
  • 环境变量等

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

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

3.2 父子进程虚拟地址空间

子进程的代码从 fork() 之后开始执行，初始用户区数据和父进程一样，但所使用的内存空间不同；内核区也会拷贝过来，但是pid进程号不同。

实际上，更准确来说，Linux 的 fork() 使用是通过 读时共享，写时拷贝 (copy- on-write) 实现。

写时拷贝是一种可以推迟甚至避免拷贝数据的技术。

内核此时并不复制整个进程的地址空间，而是让父子进程共享同一个地址空间。
只用在需要写入的时候才会复制地址空间，从而使各个进行拥有各自的地址空间。

也就是说，资源的复制是在需要写入的时候才会进行，在此之前，只有以只读方式共享。

写时复制在内核中的实现非常简单。与内核页相关的数据结构可以被标记为只读和写时复制。如果有进程试图修改一个页，就会产生一个缺页中断。内核处理缺页中断的方式就是对该页进行一次透明复制。这时会清除页面的COW属性，表示着它不再被共享。
现代的计算机系统结构中都在内存管理单元（MMU）提供了硬件级别的写时复制支持，所以实现是很容易的。

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

#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>int main() {int num = 10;// 创建文件（文件描述符fd存储在内核去的PCB中）int fd1 = open("a.txt", O_RDWR | O_CREAT | O_TRUNC, 0777);// 创建子进程pid_t pid = fork();// 判断是父进程还是子进程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);printf("parent_fd1 = %d\n", fd1);write(fd1, "parent_write1\n", 14);    // 对a.txt写入sleep(1);write(fd1, "parent_write2\n", 14);    // 在子进程关闭fd后，对a.txt写入} 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);printf("child_fd1 = %d\n", fd1);write(fd1, "child_write\n", 12);        // 对a.txt写入close(fd1);         // 关闭指向a.txt的fdint fd2 = open("b.txt", O_RDWR | O_CREAT | O_TRUNC, 0777);    // 创建新文件b.txt，printf("child_fd2 = %d\n", fd2);        // fd2 = fd1write(fd1, "child_write\n", 12);        // 对b.txt写入}// for循环for(int i = 0; i < 3; i++) {printf("i : %d , pid : %d\n", i , getpid());sleep(0.2);}return 0;
}

i am parent process, pid : 7065, ppid : 2420
parent num : 10
parent num += 10 : 20
parent_fd1 = 3
i am child process, pid : 7066, ppid : 7065
child num : 10
child num += 100 : 110
child_fd1 = 3
child_fd2 = 3
i : 0 , pid : 7066
i : 1 , pid : 7066
i : 2 , pid : 7066
i : 0 , pid : 7065
i : 1 , pid : 7065
i : 2 , pid : 7065

父子进程操作同一个文件的情况：

  1. 父进程打开一个文件后 fork()，已打开的文件描述符 fd 被子进程继承，父子进程之间共享 fork 之前打开的文件描述符和文件读写偏移量，引用计数增加，可实现对文件的接续写操作；（在执行逻辑上， fork 之前打开的文件， 要 close 两次！）
  2. 在 fork() 后父进程和子进程分别打开同一个文件，父子进程的这两个文件描述符分别指向的是不同的文件表，意味着它们有各自的文件偏移量，一个进程修改了文件偏移量并不会影响另一个进程的文件偏移量，所以实现的是独立写，写入的数据会出现覆盖的情况；
  3. 父进程和子进程分别打开同一个文件后进行写操作，打开文件时使用 O_APPEND，实现的是接续写。

3.3 GDB多进程调试

  • 设置调试进程：set follow-fork-mode [parent（默认）| child]
    使用 GDB 调试的时候，GDB 默认只能跟踪一个进程，可以在 fork 函数调用之前，通过指令设置 GDB 调试工具跟踪父进程或者是跟踪子进程，默认跟踪父进程。

  • 设置调试模式：set detach-on-fork [on | off]
    默认为 on，表示调试当前进程的时候，其它的进程脱离GDB调试继续运行，如果为 off，调试当前进程的时候，其它进程停在 fork() 处被 GDB 挂起，等待被调试。

  • 查看调试的进程：info inferiors

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

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

// hello.c
#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 < 4; i++) {printf("p = %d\n", i);sleep(1);}} else {printf("我是子进程：pid = %d, ppid = %d\n", getpid(), getppid());int j;for(j = 0; j < 4; j++) {printf("c = %d\n", j);sleep(1);}}return 0;
}
  • 设置调试进程：
cyf@cyf-virtual-machine:~/Linux/test18$ gcc hello.c -o hello -g
cyf@cyf-virtual-machine:~/Linux/test18$ ls
a.txt  b.txt  fork  fork.c  hello  hello.c
cyf@cyf-virtual-machine:~/Linux/test18$ gdb hello
GNU gdb (Ubuntu 9.2-0ubuntu1~20.04) 9.2
...
Reading symbols from hello...
(gdb) l
1       #include <stdio.h>
2       #include <unistd.h>
3
4       int main() {5
6           printf("begin\n");
7
8           if(fork() > 0) {9
10              printf("我是父进程：pid = %d, ppid = %d\n", getpid(), getppid());
(gdb) l
11
12              int i;
13              for(i = 0; i < 4; i++) {14                  printf("p = %d\n", i);
15                  sleep(1);
16              }
17
18          } else {19
20              printf("我是子进程：pid = %d, ppid = %d\n", getpid(), getppid());
(gdb) b 10      【设置断点】
Breakpoint 1 at 0x120b: file hello.c, line 10.
(gdb) b 20      【设置断点】
Breakpoint 2 at 0x1261: file hello.c, line 20.
(gdb) i b       【显示断点】
Num     Type           Disp Enb Address            What
1       breakpoint     keep y   0x000000000000120b in main at hello.c:10
2       breakpoint     keep y   0x0000000000001261 in main at hello.c:20
(gdb) r         【执行程序】
Starting program: /home/cyf/Linux/test18/hello
begin
[Detaching after fork from child process 7464]
我是子进程：pid = 7464, ppid = 7460
c = 0Breakpoint 1, main () at hello.c:10       【在父进程中断】
10              printf("我是父进程：pid = %d, ppid = %d\n", getpid(), getppid());
(gdb) c = 1            【子进程继续执行】
c = 2
c = 3
n               【next 下一行，手动执行父进程】
我是父进程：pid = 7460, ppid = 7291
13              for(i = 0; i < 10; i++) {(gdb) n
14                  printf("p = %d\n", i);
(gdb)
p = 0
15                  sleep(1);
(gdb) n
13              for(i = 0; i < 10; i++) {(gdb) n
14                  printf("p = %d\n", i);
(gdb) n
p = 1
15                  sleep(1);
(gdb) c         【手动继续执行父进程】
Continuing.
p = 2
p = 3
[Inferior 1 (process 7460) exited normally]     【程序运行完毕，退出】
(gdb) set follow-fork-mode child        【设置调试进程为child】
(gdb) show follow-fork-mode             【显示调试进程】
Debugger response to a program call of fork or vfork is "child".
(gdb) r         【执行程序】
Starting program: /home/cyf/Linux/test18/hello
begin
[Attaching after process 7947 fork to child process 7948]
[New inferior 2 (process 7948)]
[Detaching after fork from parent process 7947]
[Inferior 1 (process 7947) detached]
我是父进程：pid = 7947, ppid = 7291
p = 0
[Switching to process 7948]Thread 2.1 "hello" hit Breakpoint 2, main () at hello.c:20 【子进程进入调试】
20              printf("我是子进程：pid = %d, ppid = %d\n", getpid(), getppid());
(gdb) p = 1        【父进程不中断】
p = 2
p = 3
n
我是子进程：pid = 7948, ppid = 1
23              for(j = 0; j < 10; j++) {(gdb) c
Continuing.
c = 0
c = 1
c = 2
c = 3
[Inferior 2 (process 7948) exited normally]
(gdb)
  • 调试进程切换：
Reading symbols from hello...
(gdb) b 10          【设置断点】
Breakpoint 1 at 0x120b: file hello.c, line 10.
(gdb) b 20          【设置断点】
Breakpoint 2 at 0x1261: file hello.c, line 20.
(gdb) set detach-on-fork off    【设置子进程不脱离调试】
(gdb) r             【执行】
Starting program: /home/cyf/Linux/test18/hello
begin
[New inferior 2 (process 10068)]
Reading symbols from /home/cyf/Linux/test18/hello...
Reading symbols from /usr/lib/debug/lib/x86_64-linux-gnu/libc-2.31.so...Thread 1.1 "hello" hit Breakpoint 1, main () at hello.c:10
10              printf("我是父进程：pid = %d, ppid = %d\n", getpid(), getppid());
(gdb) n                 【默认调试父进程，此时子进程被挂起】
我是父进程：pid = 10064, ppid = 10004
13              for(i = 0; i < 10; i++) {(gdb) info inferiors    【查看调试进程，*代表当前调试的进程】Num  Description       Executable
* 1    process 10064     /home/cyf/Linux/test18/hello 2    process 10068     /home/cyf/Linux/test18/hello
(gdb) inferior 2        【切换调试进程】
[Switching to inferior 2 [process 10068] (/home/cyf/Linux/test18/hello)]
[Switching to thread 2.1 (process 10068)]
#0  arch_fork (ctid=0x7ffff7fb7810) at ../sysdeps/unix/sysv/linux/arch-fork.h:49
49      ../sysdeps/unix/sysv/linux/arch-fork.h: 没有那个文件或目录.  【忽略该错误】
(gdb) info inferiors    【查看进程】Num  Description       Executable        1    process 10064     /home/cyf/Linux/test18/hello
* 2    process 10068     /home/cyf/Linux/test18/hello
(gdb) c                 【继续调试】
Continuing.Thread 2.1 "hello" hit Breakpoint 2, main () at hello.c:20
20              printf("我是子进程：pid = %d, ppid = %d\n", getpid(), getppid());
(gdb) n                 【当前已切换为子进程调试】
我是子进程：pid = 10068, ppid = 10064
23              for(j = 0; j < 10; j++) {(gdb) n
24                  printf("c = %d\n", j);
(gdb) inferior 1        【切换调试进程】
[Switching to inferior 1 [process 10064] (/home/cyf/Linux/test18/hello)]
[Switching to thread 1.1 (process 10064)]
#0  main () at hello.c:13
13              for(i = 0; i < 10; i++) {(gdb) n
14                  printf("p = %d\n", i);
(gdb) c
Continuing.
p = 0
p = 1
p = 2
p = 3
[Inferior 1 (process 10064) exited normally]    【父进程运行完毕】
(gdb) info inferiors    【运行完后变为null，此时自动切换到子进程进行调试】Num  Description       Executable        1    <null>            /home/cyf/Linux/test18/hello
* 2    process 10068     /home/cyf/Linux/test18/hello
(gdb) n
c = 0
25                  sleep(1);
(gdb) n
23              for(j = 0; j < 10; j++) {(gdb) c
Continuing.
c = 1
c = 2
c = 3
[Inferior 2 (process 10068) exited normally]    【子进程运行完毕】
(gdb)

3.4 exec 函数族

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

  • 一般是先 fork() 创建一个进程后，在子进程执行 exec 函数来调用程序，取代子进程的内容。

  • 函数执行成功后不会返回，因为调用进程的实体，包括代码段、数据段和堆栈（用户区） 等都已经被新的内容取代，只留下进程 ID （内核区）等一些表面上的信息仍保持原样；

  • 只有调用失败了，它们才会返回 -1，从原程序的调用点接着往下执行。

 ◼ 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) 存有环境变量字符串地址的指针数组的地址

● 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);         // 指定相同目录下的可执行文件 hello// execl("/bin/ps", "ps", "aux", NULL);    // 类似于 ps aux 命令perror("execl");printf("i am child process, pid : %d\n", getpid());     // 执行execl失败才会往下执行}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.outps- 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;
}

3.5 进程控制

3.5.1 进程退出

  • 标准库函数 exit(int status)
#include <stdlib.h>
void exit(int status);
  • 系统调用函数 _exit(int status)
#include <unistd.h>
void _exit(int status);
  • 参数

status 参数：是进程退出时的一个状态信息。父进程回收子进程资源的时候可以获取到。

  • 关系

3.5.2 孤儿进程

  • 父进程运行结束，但子进程还在运行（未运行结束），这样的子进程就称为孤儿进程（Orphan Process）。
  • 每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为 init ，而 init 进程会循环地 wait() 它的子进程退出，然后回收子进程资源。
  • 因此孤儿进程并不会有什么危害。
// 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);   // 此时父进程已结束，子进程为孤儿进程，父进程设置为 1printf("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;
}

3.5.3 僵尸进程

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


在另一个终端执行 ps aux 查看进程：

执行 kill -9 25865 杀死父进程，此时僵尸子进程被 init 收养并回收资源，此时进程结束。

3.5.4 进程回收

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

退出信息相关宏函数：
◼ WIFEXITED(status) 非0，进程正常退出
◼ WEXITSTATUS(status) 如果上宏为真，获取进程退出的状态（exit的参数）

◼ WIFSIGNALED(status) 非0，进程异常终止
◼ WTERMSIG(status) 如果上宏为真，获取使进程终止的信号编号

◼ WIFSTOPPED(status) 非0，进程处于暂停状态
◼ WSTOPSIG(status) 如果上宏为真，获取使进程暂停的信号的编号
◼ WIFCONTINUED(status) 非0，进程暂停后已经继续运行

wait() 阻塞

#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);   // 相当于waitpid(-1, &st, 0);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) {        // 没有while循环时，则将正常退出，提示 “退出的状态码：0”printf("child, pid = %d\n", getpid());    sleep(1);       }               // while循环时，则需要用kill -9 pid命令终止进程，提示 “被哪个信号干掉了：9”exit(0);}return 0; // exit(0)
}


waitpid() 可设置非阻塞

#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *wstatus, int options);功能：回收指定进程号的子进程，可以设置是否阻塞。参数：- pid:pid > 0 : 某个子进程的pidpid = 0 : 回收当前进程组的所有子进程    pid = -1 : 回收所有的子进程，相当于 wait()  （最常用）pid < -1 : 某个进程组的组id的绝对值，回收指定进程组中的子进程- int *wstatus ：进程退出时的状态信息，传入的是一个int类型的地址，传出参数。    - 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;
}

4、进程间通信

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

但是，进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程间通信(IPC, Inter Processes Communication)。

进程间通信的目的：

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

Linux 进程间通信的方式：

  • 同一主机进程间通信：匿名管道、有名管道、信号、消息队列、共享内存、信号量
  • 不同主机（网络）进程间通信：Socket

4.1 匿名管道

  • 管道也叫无名（匿名）管道，它是是 UNIX 系统 IPC（进程间通信）的最古老形式，所有的 UNIX 系统都支持这种通信机制。
  • 统计一个目录中文件的数目命令：ls | wc –l，为了执行该命令，shell 创建了两个进程来分别执行 ls 和 wc。

管道的特点:

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

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

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

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

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

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

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

  • 管道默认是阻塞的：如果管道中没有数据，read 阻塞；如果管道满了，write 阻塞。

  • 为什么可以使用管道进行进程间通信？（管道具有文件的性质，可以按照操作文件的方式对管道进行操作）

  • 管道的数据结构（类比循环队列）

  • 匿名管道的使用：

      ◼ 创建匿名管道#include <unistd.h>int pipe(int pipefd[2]);功能：创建一个匿名管道，用来进程间通信。参数：int pipefd[2] 这个数组是一个传出参数。pipefd[0] 对应的是管道的读端pipefd[1] 对应的是管道的写端返回值：成功 0失败 -1管道默认是阻塞的：如果管道中没有数据，read阻塞，如果管道满了，write阻塞注意：匿名管道只能用于具有关系的进程之间的通信（父子进程，兄弟进程）◼ 查看管道缓冲大小命令ulimit –a ◼ 查看管道缓冲大小函数#include <unistd.h>long fpathconf(int fd, int name);    // name 可填宏参数 _PC_PIPE_BUF

利用匿名管道，在 fork() 之前创建管道，才能共享内核区数据（fd），父进程发送数据给子进程，子进程读取到数据输出：

管道是半双工的，两个进程无法同时读和写，因此父进程关闭管道读端fd[0]，子进程关闭写端fd[1]，保证数据的稳定性和有效性。

// pipe.c 父进程发送数据给子进程，子进程读取到数据输出
#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[0]);char buf[1024] = {0};while(1) {// 向管道中写入数据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[1]);// 从管道的读取端读取数据char buf[1024] = {0};while(1) {int len = read(pipefd[0], buf, sizeof(buf));        // 阻塞态printf("child recv : %s, pid : %d\n", buf, getpid());}   }return 0;
}

利用匿名管道实现 ps aux 示例：

子进程： ps aux, 子进程结束后，将数据发送给父进程
父进程：获取到数据，打印输出
pipe()
execlp()
dup2() 子进程将标准输出 stdout_fileno 重定向到管道的写端。

#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;               // 读取数据，多次读取数据（1023个字节，最后一个字符用于字符串结束符）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]);                   // 子进程关闭读端dup2(fd[1], STDOUT_FILENO);     // 文件描述符的重定向 STDOUT_FILENO -> fd[1]execlp("ps", "ps", "aux", NULL);// 执行 ps auxperror("execlp");exit(0);}else{perror("fork");exit(0);}return 0;
}

匿名管道的通信本质是文件的读写，可利用 fcntl() 修改为非阻塞I/O：

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wait.h>
#include <fcntl.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]);               // 父进程关闭写端int flags = fcntl(fd[0], F_GETFL);  // 得到文件状态flags |= O_NONBLOCK;                // 修改文件状态fcntl(fd[0], F_SETFL, flags);       // 设置为非阻塞char buf[1024] = {0};while(1){int len = read(fd[0], buf, sizeof(buf));printf("len = %d\n", len);printf("parent recv: %s\n\n", buf);      // 打印输出memset(buf, 0, 1024);   // 清空数据缓存sleep(1);}wait(NULL);                 // 回收子进程}else if(pid == 0){printf("i am child process, pid : %d\n", getpid());close(fd[0]);               // 子进程关闭读端char buf[1024] = {0};while(1) {                  // 向管道中写入数据char * str = "hello, i am child";write(fd[1], str, strlen(str));sleep(5);}}else{perror("fork");exit(0);}return 0;
}

4.2 有名管道

  • 匿名管道，由于没有名字，只能用于亲缘关系的进程间通信。
    为了克服这个缺点，提出了有名管道，也叫命名管道、FIFO(First In First Out)文件。
  • 有名管道（FIFO）提供了一个路径名与之关联，以 FIFO 的文件形式存在于文件系统中，并且其打开方式与打开一个普通文件是一样的，这样即使与 FIFO 的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过 FIFO 相互通信，因此，通过 FIFO 不相关的进程也能交换数据。
  • 一旦打开了 FIFO，就能在它上面使用与操作匿名管道和其他文件的系统调用一样的 I/O 系统调用了（如read()、write()和close()）。
  • 与管道一样，FIFO 也有一个写入端和读取端，并且从管道中读取数据的顺序与写入的顺序是一样的。严格遵循先进先出，对管道及 FIFO 的读总是从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如 lseek() 等文件定位操作。

有名管道（FIFO)和匿名管道（pipe）有一些特点是相同的，区别在于：

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

有名管道的使用：

  • 创建有名管道 mkfifo（命令 / 函数）

      1.通过命令： mkfifo 名字2.通过函数：#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;
}

不同进程间的有名管道通信：

有名管道的注意事项：
1.一个为只读权限打开一个管道的进程会阻塞，直到另外一个进程为只写打开管道；
2.一个为只写权限打开一个管道的进程会阻塞，直到另外一个进程为只读打开管道。（都阻塞在open语句处）

  • write.c — 子进程用于有名管道写数据，父进程监控子进程状态（读端全部关闭的异常退出信号13）
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>int main() {pid_t pid = fork(); // 创建子进程if(pid == 0){       // 子进程用于有名管道写数据printf("child write fifo open, pid = %d\n\n", getpid());// 1.判断文件是否存在int ret = access("testFIFO", F_OK);if(ret == -1) {printf("管道不存在，创建管道\n");// 2.创建管道文件ret = mkfifo("testFIFO", 0664);if(ret == -1) {perror("mkfifo");exit(0);}       }// 3.以只写的方式打开管道int fd = open("testFIFO", O_WRONLY);    // 还没出现读端时，阻塞在这里printf("write start\n");if(fd == -1) {perror("open");exit(0);}// 4.写数据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);}else if(pid > 0){      // 父进程，监控子进程状态（读端全部关闭的异常退出）printf("parent, pid = %d\n\n", getpid());int st;int ret = wait(&st); // 相当于waitpid(-1, &st, 0);if(WIFSIGNALED(st)) {   // 是不是异常终止printf("异常退出信号：%d\n", WTERMSIG(st));   }printf("child die, pid = %d\n", ret);}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.打开管道文件printf("recv open\n");int fd = open("testFIFO", O_RDONLY);    // 还没出现写端时，阻塞在这里if(fd == -1) {perror("open");exit(0);}printf("recv start\n");// 2.读数据while(1) {char buf[1024] = {0};int len = read(fd, buf, sizeof(buf));if(len == 0) {                      // 写端引用计数器为0，没有打开写端printf("写端断开连接了...\n");sleep(1);}printf("recv buf : %s\n", buf);}close(fd);return 0;
}

匿名 / 有名管道的读写特点（假设都是阻塞I/O操作）：

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

通过有名管道完成简单聊天功能：

两个 FIFO 文件，分别用于两个方向的通信。


若单个进程实现信息收发则会由于阻塞造成只能按一定顺序收发，

因此一个程序内分两个进程，父进程用于写数据、子进程用于读数据，来完成两个进程间的任意时刻的信息收发操作。

// chatA.c   chatB.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.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);}}// 创建进程pid_t pid;pid = fork();if(pid > 0){        // 父进程写// 2.以只写的方式打开管道fifo1int fdw = open("fifo1", O_WRONLY);            // 另一个文件则为 只写打开fifo2if(fdw == -1) {perror("open");exit(0);}printf("打开管道fifo1成功,等待写入...\n");char buf[128];while(1) {      // 等待数据写入memset(buf, 0, 128);// 获取标准输入的数据fgets(buf, 128, stdin);// 3.写数据ret = write(fdw, buf, strlen(buf));if(ret == -1) {perror("write");exit(0);}waitpid(-1, NULL, WNOHANG);}close(fdw);}else if(pid == 0){ // 子进程读// 4.以只读的方式打开管道fifo2int fdr = open("fifo2", O_RDONLY);        // 另一个文件则为 只读打开fifo1if(fdr == -1) {perror("open");exit(0);}printf("打开管道fifo2成功,等待读取...\n");char buf[128];while(1){       // 等待数据传出// 5.读管道数据memset(buf, 0, 128);ret = read(fdr, buf, 128);if(ret <= 0) {perror("read");break;}printf("buf: %s\n", buf);}close(fdr);}else{perror("fork");exit(0);}return 0;
}

4.3 内存映射

内存映射（Memory-mapped I/O，mmap）是将磁盘文件的数据映射到内存，用户通过修改内存就能修改磁盘文件（在原文件大小范围内）。（实现进程间通信，直接对内存进行操作，效率相对较高）

普通磁盘I/O读写文件要先把内容拷贝到页缓存（内核空间）中，然后再拷贝到用户空间中供使用，有2次拷贝。

unix访问文件的传统方法使用open打开他们，如果有多个进程访问一个文件，则每一个进程在再记得地址空间都包含有该文件的副本，这不必要地浪费了存储空间。下面说明了两个进程同时读一个文件的同一页的情形，系统要将该页从磁盘读到高速缓冲区中，每个进程再执行一个内存期内的复制操作将数据从高速缓冲区读到自己的地址空间。

而mmap读写文件是利用缺页异常把文件内容从磁盘换到用户空间中，只有1次拷贝，因此效率较高。

进程A和进程B都将该页映射到自己的地址空间，当进程A第一次访问该页中的数据时，它生成一个缺页中断，内核此时读入这一页到内存并更新页表使之指向它，以后，当进程B访问同一页面而出现缺页中断时，该页已经在内存，内核只需要将进程B的页表登记项指向此页即可。

（缺页中断就是要访问的页不在主存，需要操作系统将其调入主存后再进行访问。在这个时候，被内存映射的文件实际上成了一个分页交换文件。）

mmap()系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程可以像访问普通内存一样对文件进行访问，不必再调用read、write等操作。

更多内容参考链接

#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 ：没有权限要操作映射内存，必须要有读的权限。e.g. PROT_READ、PROT_READ|PROT_WRITE- flags :- MAP_SHARED : 映射区的数据会自动和磁盘文件进行同步，进程间通信，必须要设置这个选项- MAP_PRIVATE ：不同步，内存映射区的数据改变了，对原来的文件不会修改，会重新创建一个新的文件。（copy on write）- MAP_ANONYMOUS：匿名映射，不需要文件实体- fd: 需要映射的那个文件的文件描述符- 通过open得到，open的是一个磁盘文件- 注意：文件的大小不能为0，open指定的权限不能和prot参数有冲突。prot: PROT_READ                open:只读 / 读写 prot: PROT_READ | PROT_WRITE   open:读写- offset：偏移量，一般不用。必须指定的是4k（1024）的整数倍，0表示不偏移。- 返回值：返回创建的内存的首地址失败返回MAP_FAILED，(void *) -1int munmap(void *addr, size_t length);- 功能：释放内存映射，映射的内存在用户区堆和栈之间的共享库中，进程结束后也会自动释放。- 参数：- addr : 要释放的内存的首地址- length : 要释放的内存的大小，要和mmap函数中的length参数的值一样。
  • 内存映射的注意事项

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(1024)的整数倍，返回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()，write()
— truncate()

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

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

使用内存映射实现进程间通信（非阻塞）

  • 有关系的进程（父子进程）
    （1）准备一个大小不是 0 的磁盘文件
    （2）还没有子进程的时候,通过唯一的父进程，先创建内存映射区
    （3）有了内存映射区以后，创建子进程
    （4）父子进程共享创建的内存映射区，对文件操作实现通信
#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.打开一个文件，大小不能为0int fd = open("ipc.txt", O_RDWR | O_CREAT, 0777);write(fd, "o", 1);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, "hello, I am son.");}close(fd);// 关闭内存映射区munmap(ptr, size);return 0;
}
  • 没有关系的进程间通信
    （1）准备一个大小不是 0 的磁盘文件
    （2）进程1 通过磁盘文件创建内存映射区，得到一个操作这块内存的指针
    （3）进程2 通过磁盘文件创建内存映射区，得到一个操作这块内存的指针
    （4）使用内存映射区通信
#include <sys/types.h>
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <wait.h>
#include <stdlib.h>
int main(){pid_t pid = fork();if(pid > 0){                // 父收子发，ipc1用于B发A收，ipc2用于A发B收int fdr = open("ipc1.txt", O_RDWR | O_CREAT, 0777);     // 【mmapB.c 将 ipc1 和 ipc2 替换即可】lseek(fdr, 0, SEEK_SET);write(fdr, "", 1);     // 开头写入空格，大小非0的文件int size = lseek(fdr, 0, SEEK_END);     // 即使为1，最少也为 1024void *ptrr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fdr, 0);  // 建立映射if(ptrr == MAP_FAILED){perror("mmap");exit(0);}close(fdr);     // 关闭文件描述符，对于已映射的内存没有影响while(1){if(strlen(ptrr) > 0){  printf("read : %s", (char*)ptrr);    // 打印消息(消息中已传递回车)printf("length : %ld\n\n", strlen(ptrr));    // 打印消息memset(ptrr, 0, size);}  }munmap(ptrr, size);         // 释放映射}else if(pid == 0){int fdw = open("ipc2.txt", O_RDWR | O_CREAT, 0777);lseek(fdw, 0, SEEK_SET);write(fdw, "", 1);         // 开头写入空格，大小非0的文件int size = lseek(fdw, 0, SEEK_END);void *ptrw = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fdw, 0);  // 建立映射if(ptrw == MAP_FAILED){ perror("mmap");exit(0);}close(fdw);     // 关闭文件描述符，对于已映射的内存没有影响while(1){fgets(ptrw, 128, stdin); // 获取标准输入的数据}munmap(ptrw, size);         // 释放映射}return 0;
}

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

内存空间的大小限制了文件拷贝的内容思路：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.创建匿名内存映射区，MAP_SHARED 不可少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;
}

4.4 信号

信号是 Linux 进程间通信的最古老的方式之一，是事件发生时对进程的通知机制，有时也称之为软件中断，它是在软件层次上对中断机制的一种模拟，是一种异步通信的方式。

信号可以导致一个正在运行的进程被另一个正在运行的异步进程中断，转而处理某一个突发事件。

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

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

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

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



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

  • 信号的 5 中默认处理动作
    Term 终止进程
    Ign 当前进程忽略掉这个信号
    Core 终止进程，并生成一个Core文件
    （错误信息，ulimit -a查看配置大小，ulimit -c 1024改变Core文件大小[默认为0]，编译时gcc xxx.c -g可生成断点文件用于GDB调试，进入GDB后core-file core查看Core信息）
    Stop 暂停当前进程
    Cont 继续执行当前被暂停的进程

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

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

kill(), raise(), abort()

给进程发送信号。

 #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- 失败 非0kill(getpid(), sig);   void abort(void);- 功能： 发送SIGABRT信号给当前的进程，杀死当前进程kill(getpid(), SIGABRT);

alarm() 秒定时器

定时器，与进程的状态无关（自然定时法）。无论进程处于什么状态，alarm都会计时。

该函数是不阻塞的，每一个进程都有且只有唯一的一个 alarm() 定时器。

只定时响应一次，循环定时需要在响应时重复开启定时器。

#include <unistd.h>
unsigned int alarm(unsigned int seconds);- 功能：设置定时器（闹钟）。函数调用，开始倒计时，当倒计时为0的时候，函数会给当前的进程发送一个信号：SIGALARM- 参数：seconds: 倒计时的时长，单位：秒。如果参数为0，定时器无效（**不进行倒计时，不发信号**）。**取消一个定时器，通过alarm(0)。**- 返回值：- 之前没有定时器，返回 0- 之前有定时器，返回之前的定时器剩余的时间- SIGALARM 信号：**默认终止当前的进程**。alarm(10);  -> 返回0过了1秒alarm(5);   -> 返回9

setitimer() 微秒定时器

一个进程中只能有一个，设置一次后，不关闭则默认循环定时响应。

#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: 用户时间，时间到达，发送 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;    //  微秒    };- 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;
}

signal() 信号捕捉函数

#include <signal.h>typedef void (*sighandler_t)(int);      // int为捕捉到的信号的值
// void (*sighandler_t)(int);   // 函数指针：sighandler_t为函数指针的名称，返回值为void，参数为int类型（捕捉到的信号的值）。
// void *sighandler_t (int);    // 函数声明：void*为返回值，sighandelr_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>
#include <unistd.h>void myalarm(int num) {// alarm(1);        // 重新开启alarm定时printf("捕捉到了信号的编号是：%d\n", num);printf("xxxxxxx\n");// setitimer(ITIMER_REAL, NULL, NULL);  // 关闭itimer定时器
}// 过3秒以后，每隔2秒钟定时一次
int main() {// 设置定时器前，注册信号捕捉// signal(SIGALRM, SIG_IGN);    // 忽略信号// signal(SIGALRM, SIG_DFL);    // 默认处理signal(SIGALRM, myalarm);struct itimerval new_value;// 设置间隔的时间new_value.it_interval.tv_sec = 1;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); // 非阻塞的if(ret == -1) {perror("setitimer");exit(0);}// alarm(1);    // 不重复定时printf("定时器开始了...\n");getchar();return 0;
}

信号集

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

信号处理流程：

 1.用户通过键盘  Ctrl + C, 产生2号信号SIGINT (信号被创建)2.信号产生但是没有被处理 （未决）- 在内核中将所有的没有被处理的信号存储在一个集合中 （未决信号集）- SIGINT信号状态被存储在第二个标志位上- 这个标志位的值为0， 说明信号不是未决状态- 这个标志位的值为1， 说明信号处于未决状态3.这个未决状态的信号，需要被处理，处理之前需要和另一个信号集（阻塞信号集），进行比较- 阻塞信号集**默认不阻塞任何的信号**- 如果想要阻塞某些信号需要用户调用**系统的API**4.在处理的时候和阻塞信号集中的标志位进行查询，看是不是对该信号设置阻塞了- 如果没有阻塞，这个信号就被处理- 如果阻塞了，这个信号就继续处于未决状态，直到阻塞解除，这个信号就被处理

(对自定义的)信号集相关的函数：

int sigemptyset(sigset_t *set);- 功能：清空信号集中的数据,将信号集中的所有的标志位置为0- 参数：set,传出参数，需要操作的信号集- 返回值：成功返回0， 失败返回-1int sigfillset(sigset_t *set);- 功能：将信号集中的所有的标志位置为1- 参数：set,传出参数，需要操作的信号集- 返回值：成功返回0， 失败返回-1int sigaddset(sigset_t *set, int signum);- 功能：设置信号集中的某一个信号对应的标志位为1，表示阻塞这个信号- 参数：- set：传出参数，需要操作的信号集- signum：需要设置阻塞的那个信号- 返回值：成功返回0， 失败返回-1int sigdelset(sigset_t *set, int signum);- 功能：设置信号集中的某一个信号对应的标志位为0，表示不阻塞这个信号- 参数：- set：传出参数，需要操作的信号集- signum：需要设置不阻塞的那个信号- 返回值：成功返回0， 失败返回-1int sigismember(const sigset_t *set, int signum);- 功能：判断某个信号是否为 1- 参数：- set：需要操作的信号集- signum：需要判断的那个信号- 返回值：1 ： signum 为 10 ： signum 为 0-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"); // SIGINT 不阻塞} 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"); // SIGINT 阻塞}// 判断SIGQUIT是否在信号集中ret = sigismember(&set, SIGQUIT);if(ret == 0) {printf("SIGQUIT 不阻塞\n");} else if(ret == 1) {printf("SIGQUIT 阻塞\n");    // SIGQUIT 阻塞}// 从信号集中删除一个信号sigdelset(&set, SIGQUIT);// 判断SIGQUIT是否在信号集中ret = sigismember(&set, SIGQUIT);if(ret == 0) {printf("SIGQUIT 不阻塞\n");    // SIGQUIT 不阻塞} else if(ret == 1) {printf("SIGQUIT 阻塞\n");}return 0;
}

sigprocmask() 系统调用设置阻塞信号集：

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);- 功能：将自定义信号集中的数据设置到内核中（设置阻塞，解除阻塞，替换）- 参数：- how : 如何对内核阻塞信号集进行处理SIG_BLOCK: 将用户设置的阻塞信号集添加到内核中，内核中原来的数据位为 1 的状态不变假设内核中默认的阻塞信号集是mask， mask | setSIG_UNBLOCK: 根据用户设置的数据，对内核中的数据进行解除阻塞mask &= ~set （取反后 与）SIG_SETMASK:覆盖内核中原来的值- set ：已经初始化好的用户自定义的信号集- oldset : 保存设置之前的内核中的阻塞信号集的状态，可以是 NULL- 返回值：成功：0失败：-1，设置错误号：EFAULT、EINVALint sigpending(sigset_t *set);- 功能：获取内核中的未决信号集- 参数：set,传出参数，保存的是内核中的未决信号集中的信息。

#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);    // ctrl + Csigaddset(&set, SIGQUIT);   // ctrl + \
// 修改内核中的阻塞信号集，信号阻塞，不能用ctrl + C终止进程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) {// 解除阻塞，可以用ctrl + C终止进程sigprocmask(SIG_UNBLOCK, &set, NULL);}}return 0;
}

cyf@cyf-virtual-machine:~/Linux/test26$ ./pro
0000000000000000000000000000000
0000000000000000000000000000000
^C0100000000000000000000000000000
0100000000000000000000000000000
0100000000000000000000000000000
0100000000000000000000000000000
0100000000000000000000000000000
0100000000000000000000000000000
0100000000000000000000000000000
0100000000000000000000000000000[1]+  已杀死               ./pro

sigaction() 信号捕捉，检查或改变信号的处理

函数说明：
相对于信号捕捉函数signal()，sigaction()更复杂一点，但是其标准兼容更多的系统和版本。

sigaction 在回调中使用的是临时阻塞信号集，执行完回调后，恢复到系统的阻塞信号集。

常规的信号阻塞的时候是不支持排队的，即未决信号集只有一个 0 或 1 的标记位，不能记录相关信号的触发次数。（后面32个实时信号是支持排队的）

#include <signal.h>
int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);- 功能：检查或者改变信号的处理。信号捕捉- 参数：- signum : 需要捕捉的信号的编号或者宏值（信号的名称）- act ：捕捉到信号之后的处理动作- oldact : 上一次对信号捕捉相关的设置，一般不使用，传递NULL- 返回值：成功 0失败 -1struct 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;// 被废弃掉了void     (*sa_restorer)(void);
};

示例：

#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>void myalarm(int num) {// alarm(1);        // 重新开启alarm定时printf("捕捉到了信号的编号是：%d\n", num);printf("xxxxxxx\n");// setitimer(ITIMER_REAL, NULL, NULL);  // 关闭itimer定时器
}// 过3秒以后，每隔2秒钟定时一次
int main() {// 设置定时器前，注册信号捕捉struct sigaction act;           // 新建相关结构体act.sa_flags = 0;               // 调用sa_handleract.sa_handler = myalarm;       // 回调函数sigemptyset(&act.sa_mask);      // 清空（act默认的）临时阻塞信号集sigaction(SIGALRM, &act, NULL); // 设置信号捕捉struct itimerval new_value;// 设置间隔的时间new_value.it_interval.tv_sec = 1;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); // 非阻塞的if(ret == -1) {perror("setitimer");exit(0);}// alarm(1);    // 不重复定时printf("定时器开始了...\n");// getchar();   // 这里不能使用 `getchar()` 阻塞进程，// 因为使用 `sigaction` 捕获信号后 `getchar()` 将从stdin流中读取到EOF，也就是返回了-1，所以进程会直接向下执行而终止。// 但是 `signal` 中则会一直阻塞在 `getchar()` 。while (1);  // 阻塞进程return 0;
}

内核实现信号捕捉的过程

两次相同的信号先后递送，在第一次相关回调函数执行完后，才回执行下一次的回调函数。

SIGCHLD 信号（避免僵尸进程）

SIGCHLD信号产生的3个条件：1.子进程结束2.子进程接收到 SIGSTOP 信号暂停时3.子进程处在停止态，接受到 SIGCONT 后唤醒时以上三种条件都会给父进程发送 SIGCHLD 信号，父进程默认会忽略该信号

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

父进程捕捉到SIGCHLD信号后，才中断调用 waitpid() 进行进程回收，可以避免父进程循环 wait() 占用资源。

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#include <sys/wait.h>void myFun(int num) {printf("捕捉到的信号: %d\n", num);// 回收子进程PCB的资源// 1. 捕捉到信号后进行wait回收// wait(NULL); //  一次回收一个子进程，若多个进程同时结束并发送SIGCHLD信号，// 但是由于该未决信号是不能记录个数的，因此这些信号中只能调用一次wait，回收一个子进程，剩余子进程未被回收// 2. 针对以上问题，写入while循环，直到没有子进程才跳出// while(1) {//     printf("while\n");//     int ret = wait(NULL);  //     if(ret > 0) {//         printf("child die , pid = %d\n", ret);//     } else if(ret == -1) {//         // 没有子进程//         break;//     }// }// 3. 使用waitpid，设置非阻塞，还有子进程存在时依然可以跳出循环while(1) {printf("while\n");int ret = waitpid(-1, NULL, WNOHANG);    // 设置成非阻塞if(ret > 0) {printf("child die , pid = %d\n", ret);} else if(ret == 0) {// 说明还有子进程或者break;} 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);// 注册完信号捕捉以后，解除阻塞sigprocmask(SIG_UNBLOCK, &set, NULL);while(1) {printf("parent process pid : %d\n", getpid());sleep(2);}} else if( pid == 0) {// 子进程printf("child process pid : %d\n", getpid());sleep(0.5);     // 等待后退出，对比 wait 与 waitpid 的阻塞与非阻塞}return 0;
}

4.5 共享内存

共享内存的实现方式分为两种，分别是基于物理内存实现和基于内存映射实现。
4.3 已讲到内存映射需要将磁盘文件的数据映射到内存，用户通过修改内存来修改磁盘文件，进而实现共享了这个磁盘文件映射的进程进行通信，但是涉及到磁盘文件的读写；虽然匿名映射不需要指定文件，但是只能用于具有亲缘关系的进程间通信。

共享内存和内存映射的区别：

  1. 共享内存可以直接创建，内存映射需要磁盘文件（匿名映射除外）
  2. 共享内存效果更好
  3. 内存
    共享内存，所有的进程操作的是同一块共享内存。
    内存映射，每个进程在自己的虚拟地址空间中有一个独立的内存映射到指定磁盘文件上。
  4. 数据安全
    进程突然退出：
    – 共享内存还存在
    – 内存映射区自动释放
    运行进程的电脑死机，宕机了：
    – 数据存在在共享内存中，没有了
    – 内存映射区的数据 ，由于磁盘文件中的数据还在，所以内存映射区的数据还存在。
  5. 生命周期
    – 内存映射区：进程退出，内存映射区销毁
    – 共享内存：进程退出，共享内存还在，标记删除（所有的关联的进程数为0），或者关机
    如果一个进程退出，会自动和共享内存进行取消关联。

此处介绍基于物理内存实现的共享内存。

共享内存允许两个或者多个进程共享物理内存的同一块区域（通常被称为段），每个进程可以将自身的虚拟地址映射到物理内存中的特定区域，共享内存段会成为进程用户空间的一部分，因此这种 IPC 机制无需内核介入。

共享内存是最高效的进程间通信的方式。

共享内存只需要两次拷贝即可实现，即数据从进程A的用户空间到内存，再从内存到进程B的用户空间。

A用户空间 -> 内存 -> B用户空间

而管道等要求进程需要通过用户空间和内核内存间进行数据拷贝的做法则需要四次拷贝：首先将数据从进程A的用户空间拷贝到进程A的内核空间，其次将数据从进程A的内核空间拷贝到内存中，之后数据又从内存被拷贝到进程B的内核空间，最后数据从进程B的内核空间拷贝到进程B的用户空间中。

A用户空间 -> A内核空间 -> 内存 -> B内核空间-> B用户空间

共享内存没有进程间同步与互斥机制。例如，进程A对共享内存执行写操作，在A的写入结束之前，进程B就可以从共享内存区读取数据，并无某种自动的机制来阻止进程B的读操作。一般为了实现进程同步和互斥，常常将共享内存和信号量配合使用。

共享内存使用步骤：

  • 调用 shmget() 创建一个新共享内存段或获取一个既有共享内存段的标识符（即由其他进程创建的共享内存段）。这个调用将返回后续调用中需要用到的共享内存标识符。
  • 使用 shmat() 来关联共享内存段，即使该段成为调用进程的虚拟内存的一部分。
  • 此刻在程序中可以像对待其他可用内存那样对待这个共享内存段。为引用这块共享内存，程序需要使用由 shmat() 调用返回的 addr 值，它是一个指向进程的虚拟地址空间中该共享内存段的起点的指针。
  • 调用 shmdt() 来分离共享内存段。在这个调用之后，进程就无法再引用这块共享内存了。这一步是可选的，并且在进程终止时会自动完成这一步。
  • 调用 shmctl() 来删除共享内存段。只有当当前所有关联内存段的进程都与之分离之后内存段才会销毁。只有一个进程需要执行这一步。

共享内存的相关函数：

#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'

共享内存操作命令：

◼ 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标识的信号

共享内存实现 IPC 示例：

  • 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;
}
  • 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);   // 有一个进程执行后，该 shm 的 key 就变成 0 return 0;
}

问题1：操作系统如何知道一块共享内存被多少个进程关联？
- 共享内存维护了一个结构体 struct shmid_ds 这个结构体中有一个成员 shm_nattch
- shm_nattach 记录了关联的进程个数
终端执行命令 ipcs -m

问题2：可不可以对共享内存进行多次删除 shmctl ？
可以的
因为 shmctl 标记删除共享内存，不是直接删除
- 什么时候真正删除呢?
当和共享内存关联的进程数为 0 的时候，就真正被删除
- 当共享内存的 key为 0 的时候，表示共享内存被标记删除了
如果一个进程和共享内存取消关联，那么这个进程就不能继续操作这个共享内存。也不能进行关联。

共享内存IPC 实现简单聊天功能：

// shmA.c  &   shmB.c
#include <sys/types.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <wait.h>
#include <stdlib.h>int idr, idw;
void *ptrr, *ptrw;void releaseQuit(int num){          // 捕捉Ctrl + C结束信号，释放内存shmdt(ptrr);                    // 解除关联shmctl(idr, IPC_RMID, NULL);    // 删除共享内存shmdt(ptrw);shmctl(idw, IPC_RMID, NULL);
}int main(){struct sigaction act;           // 新建相关结构体act.sa_flags = 0;               // 调用sa_handleract.sa_handler = releaseQuit;   // 回调函数sigemptyset(&act.sa_mask);      // 清空（act默认的）临时阻塞信号集sigaction(SIGINT, &act, NULL); // 设置信号捕捉  ctrl + Cpid_t pid = fork();if(pid > 0){                // 父收子发，key = 1用于B发A收，key = 2用于A发B收key_t key1 = 1;           // 2 for shmB.cidr = shmget(key1, 4096, IPC_CREAT | 0664); // 获取一个共享内存ptrr = shmat(idr, NULL, 0);              // 关联while(1){if(strlen(ptrr) > 0){  printf("read : %s", (char*)ptrr);    // 打印消息(消息中已传递回车)printf("length : %ld\n\n", strlen(ptrr));    // 打印消息memset(ptrr, 0, 4096);}   }}else if(pid == 0){key_t key2 = 2;         // 1 for shmB.cidw = shmget(key2, 4096, IPC_CREAT | 0664);ptrw = shmat(idw, NULL, 0);while(1){fgets(ptrw, 1024, stdin); // 获取标准输入的数据}}return 0;
}

4.6 消息队列

什么是消息队列？
深入消息队列MQ

消息队列（Message Queue，简称MQ），指保存消息的一个容器，本质是个队列（先进先出）。

消息（Message）是指在应用之间传送的数据，消息可以非常简单，比如只包含文本字符串，也可以更复杂，可能包含嵌入对象。

下图便是消息队列的基本模型，向消息队列中存放数据的叫做生产者，从消息队列中获取数据的叫做消费者。

消息队列中间件是分布式系统中重要的组件，主要解决异步处理、应用解耦、流量削锋等问题，实现高性能、高可用、可伸缩和最终一致性架构。

1. 异步处理

引入消息队列，将非主要的业务逻辑进行异步处理，主要目的是减少请求响应时间，实现非核心流程异步化，提高系统响应性能。

场景说明：用户注册后，需要发注册邮件和注册短信提醒。传统的做法有两种 1.串行方式；2.并行方式

假设三个业务节点每个使用50毫秒钟，不考虑网络等其他开销，则串行方式的时间是150毫秒，并行的时间可能是100毫秒。

消息队列在异步的典型场景就是将比较耗时而且不需要即时（同步）返回结果的操作，通过消息队列来实现异步化。


按照以上约定，用户的响应时间相当于是注册信息写入数据库的时间，也就是50毫秒。注册邮件、发送短信写入消息队列后，直接返回，因此写入消息队列的速度很快，基本可以忽略，因此用户的响应时间可能是50毫秒。因此架构改变后，系统的吞吐量提高到每秒20 QPS。比串行提高了3倍，比并行提高了2倍。

2. 应用解耦

如果模块之间不存在直接调用，那么新增模块或者修改模块就对其他模块影响较小，耦合性低，这样系统的可扩展性无疑更好一些。

使用了消息队列后，只要保证消息格式不变，消息的发送方和接收方并不需要彼此联系，也不需要受对方的影响，即解耦。

每个成员不必受其他成员影响，可以更独立自主，只通过消息队列MQ来联系，典型的上下游解耦如下图所示：

3. 流量削峰

流量削锋也是消息队列中的常用场景，一般在秒杀或团抢活动中使用广泛。

应用场景：秒杀活动，一般会因为流量过大，导致流量暴增，应用挂掉。为解决这个问题，一般需要在应用前端加入消息队列，相当于做了一次缓冲。

a、可以控制活动的人数
b、可以缓解短时间内高流量压垮应用

用户的请求，服务器接收后，首先写入消息队列；
假如消息队列长度超过最大数量，则直接抛弃用户请求或跳转到错误页面；
秒杀业务根据消息队列中的请求信息，再做后续处理。

4. 日志处理

日志处理是指将消息队列用在日志处理中，比如Kafka的应用，解决大量日志传输的问题。架构简化如下：


日志采集客户端：负责日志数据采集，定时写受写入Kafka队列；
Kafka消息队列：负责日志数据的接收，存储和转发；
日志处理应用：订阅并消费kafka队列中的日志数据。

5. 消息通讯

消息队列一般都内置了高效的通信机制，因此也可以用在纯的消息通讯。比如实现点对点消息队列，或者聊天室等。

  • 点对点通讯：
    客户端A（发送者）和客户端B（接受者）使用同一消息队列，进行消息通讯。

  • 聊天室通讯：
    客户端A，客户端B…客户端N订阅同一主题，进行消息发布和接收。实现类似聊天室效果。

以上实际是消息队列的两种消息模式，点对点和发布订阅模式。

每个消息只有一个消费者（Consumer）(即一旦被消费，消息就不再在消息队列中)；
发送者和接收者之间在时间上没有依赖性；
接收者在成功接收消息之后需向队列应答成功。

每个消息可以有多个消费者：和点对点方式不同，发布消息可以被所有订阅者消费；
发布者和订阅者之间有时间上的依赖性；
针对某个主题（Topic）的订阅者，它必须创建一个订阅者之后，才能消费发布者的消息；
为了消费消息，订阅者必须保持运行的状态。

4.7 信号量

信号量（semaphore）是操作系统用来解决并发中的（进程或者线程）互斥和同步问题的一种方法。

对于信号量的值 n（允许进入临界区的线程/进程数）：
n > 0：当前有可用资源，可用资源数量为 n
n = 0：资源都被占用，可用资源数量为 0
n < 0：资源都被占用，并且还有 n 个进程正在排队

信号量可以但不一定实现互斥（不是说不能，一种情况是不存在共享临界区，谈不上互斥，另一种情况是允许共同进入临界区，比如读操作），肯定实现了同步。

可用于进程间共享内存的进程同步问题。

sem_t sem;   // 信号量的类型
int sem_init(sem_t *sem, int pshared, unsigned int value);- 初始化信号量- 参数：- sem : 信号量变量的地址- pshared : 【0 用在线程间 ，非 0 用在进程间】- value : 信号量中的值
int sem_destroy(sem_t *sem);- 释放资源
int sem_wait(sem_t *sem);- 对信号量加锁，调用一次对信号量的值-1，如果值为0，就阻塞
int sem_trywait(sem_t *sem);
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);
int sem_post(sem_t *sem);- 对信号量解锁，调用一次对信号量的值+1
int sem_getvalue(sem_t *sem, int *sval);

4.8 socket 套接字

用于网络中不同主机之间的进程间通信

5、守护进程

终端

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

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

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

      echo $$   // 查看当前终端的进程号pidtty     // 查看当前终端（设备） /dev/pts/3

进程组 和 会话

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

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

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

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

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

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

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

find / 2 > /dev/null | wc -l &
查找 2   > 重定向到/dev/null  | 管道   wc -l 统计   & 后台运行sort < longlist | uniq -c


相关操作函数：

◼ 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

守护进程

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

  • 守护进程具备下列特征：
    – 生命周期很长，守护进程会在系统启动的时候被创建并一直运行直至系统被关闭。
    – 它在后台运行并且不拥有控制终端。没有控制终端确保了内核永远不会为守护进程自动生成任何控制信号以及终端相关的信号（如 SIGINT、SIGQUIT）。

  • Linux 的大多数服务器就是用守护进程实现的。比如，Internet 服务器 inetd，Web 服务器 httpd 等。

守护进程的创建步骤：

  • 执行一个 fork()，之后父进程退出，子进程继续执行；
    退出父进程，防止终端知道父进程结束后显示shell提示符；因为要开启新的会话，因此子进程作为守护进程可以确保守护进程开启的新会话id与原id不冲突。

  • 子进程调用 setsid() 开启一个新会话，新会话默认没有控制终端；
    子进程产生以子进程id为id的进程组和会话，新会话脱离控制终端（还是有终端）。

  • 清除进程的 umask 以确保当守护进程创建文件和目录时拥有所需的权限。（非必须）

  • 修改进程的当前工作目录，通常会改为根目录（/）。

  • 关闭守护进程从其父进程继承而来的所有打开着的文件描述符；
    避免对标准输入输出等进行终端操作。

  • 在关闭了文件描述符0、1、2之后，守护进程通常会打开/dev/null 并使用dup2() 使所有这些描述符指向这个设备；
    重定向 0 1 2到null，避免调用的系统调用用到了这些文件描述符，但却因关闭了产生错误；重定向到null写的数据会被丢弃。

  • 核心业务逻辑

/*写一个守护进程，每隔2s获取一下系统时间，将这个时间写入到磁盘文件中。
*/#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.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_RDWR | O_CREAT | O_APPEND, 0664);write(fd ,str, strlen(str));close(fd);
}int main() {// 1.创建子进程，退出父进程pid_t pid = fork();if(pid > 0) {exit(0);}// 2.将子进程重新创建一个会话setsid();// 3.设置掩码umask(022);// 4.更改工作目录// chdir("/home/cyf/");// 5. 关闭、重定向文件描述符 dup2(new, old)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 = 0;        // 延迟时间val.it_value.tv_usec = 1;val.it_interval.tv_sec = 2;     // 时钟周期val.it_interval.tv_usec = 0;setitimer(ITIMER_REAL, &val, NULL);// 不让进程结束while(1) {sleep(10);}return 0;
}

6、Linux多进程开发相关推荐

  1. Linux 高并发服务器实战 - 2 Linux多进程开发

    Linux 高并发服务器实战 - 2 Linux多进程开发 进程概述 概念1: 概念2: 微观而言,单CPU任意时刻只能运行一个程序 并发:两个队列交替使用一台咖啡机 并行:两个队列同时使用两台咖啡机 ...

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

    HTTP服务器项目2:Linux多进程开发 1.进程概述: 01 / 程序和进程 程序是包含一系列信息的文件,这些信息描述了如何在运行时创建一个进程: ◼ 二进制格式标识:每个程序文件都包含用于描述可 ...

  3. Linux 多进程开发

    Linux多进程开发 文章目录 进程概述 程序与进程 单道.多道程序设计 时间片 并行和并发 进程状态转换 进程的状态 进程相关命令 进程号和相关函数 进程创建 父子进程的虚拟地址空间 父子进程之间的 ...

  4. Linux多进程开发（三）进程创建之守护进程的学习

       之前发过一篇守护进程的文章,但是解析的不够详细,这次,详细来解释守护进程的一些概念和特性.   概念: 后台运行.没有控制端与之相连的进程.独立于控制终端,通常周期性的执行某种任务.    Wh ...

  5. 2022-1-15 牛客C++项目——第二章 Linux 多进程开发

    一.进程的的退出 问题:为什么使用标准 C 库函数和使用 Linux 的系统函数最后会有两个截然不同的结果呢? exit() #include<stdio.h> #include<s ...

  6. 2022-1-13牛客网C++项目—— 第二章 Linux 多进程开发（一）

    复习用的问题 进程和程序之间的关系是什么? 进程包含了哪些信息? 一.程序当中包含了一系列的信息,这些信息用于描述如何创建一个进程. 1)二进制格式标识:描述文件的格式,内核根据这个信息来解释文件中的 ...

  7. Linux后台开发必看！

    来自:我是程序员小贱 一 自我介绍二 面试情况三 相关知识点汇总1 c/c++相关2 计算机网络3 数据结构相关4 数据库相关5 操作系统6 Linux基础知识及应用编程(后台必备!)7 大数问题8 ...

  8. Linux后台开发应该具备技能

    Linux后台开发应该具备技能 一.linux和os: 1.命令:netstat tcpdump ipcs ipcrm  这四个命令的熟练掌握程度基本上能体现实际开发和调试程序的经验 2.cpu 内存 ...

  9. fseek linux 大文件_一文搞懂Linux系统开发

    文章目录 Linux系统开发会用到什么? C语言基础 shell脚本 慢慢学会使用Makefile 常规Linux系统编程知识都有什么?哪些常用?哪些不常用? 常规Linux编程知识 文件IO 文件与 ...

最新文章

  1. Ghost 系统的过程
  2. Linux下运行Jmeter脚本
  3. UEFI下面安装win7+Xubuntu18.10双系统
  4. 自定义View 进度条
  5. tensorflow2 目标检测_基于光流的视频目标检测系列文章解读
  6. mysql udb_MySQL InnoDB的一些参数说明
  7. 是什么使波西米亚狂想曲成为杰作-数据科学视角
  8. Delphi中destroy, free, freeAndNil, release用法和区别
  9. sping加载bean都发生了些什么
  10. 在线教学试卷讲评利器——屏幕画笔
  11. C语言嵌入式系统编程修炼之键盘操作
  12. 计算机编程及常用术语英语词汇大全
  13. 深度学习记录第二篇————Tensor基本操作
  14. 【渝粤教育】国家开放大学2018年秋季 2129T药物化学 参考试题
  15. hive 学习系列五（hive 和elasticsearch 的交互，很详细哦，我又来吹liubi了）
  16. 闽侯一中2021年高考成绩查询,2021年福州高考各高中成绩及本科升学率数据排名及分析...
  17. 细说安装php的webp文件格式支持
  18. 使用python绘制奥运五环
  19. 【python】argv的用法
  20. 基于imx6ull打造流媒体视频监控：ffmpeg + nginx + rtmp

热门文章

  1. 在Word里怎么设置每页不同的页眉
  2. 微信分享之SPA的坑
  3. 【C标准库1】math.h
  4. casio计算机如何计算标准差,怎样在卡西欧5800里计算标准差和方差，不要普通计算，用里面设计好的模式，...
  5. [转]奇文-闲话操作系统(2/4)
  6. 西门子1200plc两部六层电梯程序
  7. Java学习笔记（三）：流程控制
  8. 不知道如何回复审稿人意见？回复模板来了！
  9. sql server中datename函数的使用
  10. SQL中将年月日， DATE_FORMAT()格式转换指定格式