【Hello Linux】进程控制 (内含思维导图)

作者：@小萌新
专栏：@Linux
作者简介：大二学生 希望能和大家一起进步！
本篇博客简介：简单介绍下进程的控制 包括进程启动 进程终止 进程等待 进程替换等概念

介绍

下面我们将分别从进程创建 进程终止 进程等待 进程替换四个方面来介绍进程控制相关内容
我们会先从进程相关函数的使用开始学习直至了解其底层原理
最后我们将灵活运用上面学到的所有知识来写一个简单的shell程序

进程创建

fork函数

我们学习到目前为止一共有两种比较常见的创建进程方式

一种是直接输入可执行文件 比如说 ls ll等 这实际上就是创建了一个进程

还有一种方式就是通过调用fork()函数来在已存在的进程中创建一个进程

新创建的进程叫做子进程 原来的进程叫做父进程

fork函数的返回值

一般来说对于一个函数而言 返回值我们不必讲解 但是fork函数很特殊

因为它有两个返回值 一个是给父进程的返回值 一个是给子进程的返回值

我们从系统的角度来理解一下为什么存在两个返回值

在前面的博客中我们知道了 进程其实就是 程序+PCB+mm_struct+页表

我们在调用fork这个函数的时候 操作系统会对子进程进行创建PCB以及

mm_struct和页表映射等一系列操作 当程序计数器走到return pid这一步的时候事实上的子进程已经被创建完毕了

所以说父子进程都走到了这一步 所以会有两个返回值也就不奇怪了

• 如果创建子进程失败便会对父进程返回-1
• 如果创建子进程成功便会对父进程返回子进程pid 对子进程返回0

为什么我们对于父进程就是返回pid 对于进程就直接返回0呢？

因为父进程对于子进程是一个一对多的关系 一个父进程能够创建很多个子进程 所以说父进程需要知道子进程的pid才能够唯一标识之

而子进程对于父进程是一个一对一的关系 一个子进程只能有一个父进程 所以说对于子进程来说并不需要特别标识什么

fork函数的使用

我们使用fork函数一般是因为要通过多个进程去处理问题

所以说一般是让父子进程去做不同的事情

上面的返回值部分我们也解释过 我们可以通过返回值来分辨父子进程

那么一个简单的多进程C++示例程序就可以这么写

  1 #include <unistd.h>
  2 #include <stdio.h>
  3 #include <iostream>
  4 using namespace std;
  5 
  6 int main()
  7 {
  8   int ret = fork();
  9   if (ret == 0)
 10   {
 11     // child                                                             
 12     printf("im child my pid is:%d my ppid is:%d\n",getpid(),getppid());
 13   }
 14   else 
 15   {
 16     // father
 17     printf("im father my pid is:%d my ppid is:%d\n",getpid(),getppid());
 18     sleep(1);                                                            
 19   }
 20 
 21   return 0;
 22 }

我们让父子进程分别打印它们的pid和它们父进程的pid 在linux下运行效果如下

我们可以发现子进程的pid就是父进程的ppid

我们在写业务的时候如果需要使用多进程 可以直接将if else里面的逻辑替换

写时拷贝技术

子进程的创建过程中会伴随着PCB mm_struct的创建 页表映射

一般来说父子进程的代码和数据都是共享的 所以它们会被页表映射到同一物理地址中

但是对于子进程来说 我们有可能会修改它的各项数据 此时便会发生写时拷贝

子进程的页表会重新映射一份物理内存给子进程

但是此时子进程的mm_struct地址却没有改变

所以这就会造成一个很奇怪的现象

那就是打印出来的地址相同 可是地址里面的数值不同

造成这个现象的原因其实就是虚拟地址没有变而物理地址变化了

我们为什么要进行写时拷贝呢？

因为进程具有独立性 比如说上面的例子 如果我们不进行写时拷贝的话子进程数据的修改就会影响到父进程了

为什么不在创建子进程的时候就进行数据的拷贝？

这是因为子进程有可能不会修改数据 所以说我们没有必要进行数据拷贝 直接共享父进程的数据可以更高效的使用内存空间

代码会不会进行写时拷贝？

代码一般情况下不会进行写时拷贝 当然代码也可以进行写时拷贝 比如说我们后面讲到的进程替换就用到了代码的写时拷贝

fork常规用法

1. 一个进程希望复制自己 使子进程同时执行不同的代码段 例如父进程等待客户端请求 生成子进程来处理请求
2. 一个进程要执行一个不同的程序 例如子进程从fork返回后 调用exec函数

fork调用失败的原因

1. 系统中有太多的进程 内存空间不足 子进程创建失败
2. 实际用户的进程数超过了限制 子进程创建失败

进程终止

进程退出的场景

进程退出一共有三种场景

1. 代码运行完毕 结果正确
2. 代码运行完毕 结果错误
3. 代码异常终止

进程退出码

我们在写c语言程序的时候 一般会在最后面加上return 0

那么大家有没有想过 这个return 0是返回给谁的呢？

我们在C/C++中 在代码最后都会写上return 0; 对于这个返回值我们称它为进程退出码 对于正确的进程一般都以0作为进程退出码 而非0就作为错误的进程的退出码 因此不同的错误对应的退出码也是不同的

比如说我们写出下面的这样一个代码

如果说我们的运行结果是正确的话 我们最后返回的就是0

如果运行的结果是错误的话 我们最后返回的就是一个错误码

这个错误码可能是一个整数 这个整数代表着各种各样的错误

在c语言中 我们可以使用下面的这段代码来获取所有的错误码

那么我们可以如何获取错误码呢？

在linux中 我们可以通过下面的代码来获取上一个进程的错误码

   echo $?

如果我们运行上面的程序 我们可以发现退出码是0

如果我们稍微修改下程序 让==变成 != 那么我们就会发现退出码是1

当我们调用系统进程 比如说ls ll的时候 实际上它们也会有一个返回码

当我们正常使用的时候 这个返回码就是0

如果我们使用失败的话 它也会返回我们一个错误码 来告诉我们为什么失败

进程正常退出

在linux中 我们让进程退出一般有三种方式

• return退出
• exit函数退出
• _exit函数退出

下面我们将分别写出代码来介绍这三种退出方式

return

上面是我们验证return退出进程的代码

我们可以使用

 echo  $?

来查看上一个进程的退出码 下面的退出也是使用这种方式

我们使用的时候不再赘述

事实上我们return的也确实是0

exit

我们除了可以使用return退出之外还可以使用exit来退出一个进程

它的使用方式如下

代码如下

接下来我们接受退出码 我们发现确实是10

_exit

我们在写代码的时候 并不常用_exit函数

它能够在任何地方强制退出进程 直接清空缓冲区 不输出任何的数据

我们编译后执行这段代码 我们会发现没有任何的数据被打印

接下来 我们继续调用echo $?来获取进程的退出码

我们能够获取到进程的退出码是30

return exit _exit之间的区别和联系

区别

• return只有在主函数中才有退出进程的功能 在子函数中是没有这个功能的 而exit和_exit在任何地方都可以退出进程
• exit和return在结束进程的时候会执行用户的清除函数 刷新缓冲区 关闭流等 而_exit则会直接退出 什么都不会做

联系

实际上我们在主函数中的return num 就相当于调用了 exit（num）

而exit（num）在执行完用户定义的清理函数 清空缓冲区 关闭流之后还是会调用_exit函数

进程异常退出

在linux中 进程异常退出一般有两种方式

• 释放kill信号给进程后退出
• 出现如 除0问题 指针越界等问题程序终止

进程等待

进程等待的必要性

• 子进程退出 父进程如果不读取子进程的退出信息 子进程就会变成僵尸进程 进而造成内存泄漏
• 进程一旦变成僵尸进程 那么就算是kill -9命令也无法将其杀死 因为谁也无法杀死一个已经死去的进程
• 父进程派给子进程的任务完成的如何 我们需要知道 子进程运行完成 结果对还是不对 是否正常退出
• 父进程通过进程等待的方式 回收子进程资源 获取子进程退出信息

上面是比较详细的说法

我们进程等待最主要的原因就是为了让父进程等待子进程结束回收资源 获取信息 避免子进程变成僵尸进程

如何进行进程等待

wait

我们可以使用wait函数来让父进程等待子进程运行结束

它的函数使用方法如下

pid_t wait(int* status);

它的返回值是一个pid_t类型的数据 如果等待成功会返回这个进程的pid 等待失败则会返回-1

它的参数是一个指针 这个指针我们会在后面详细讲解

它的作用是让父进程等待任意子进程

我们写出下面的代码 它的目的是为了验证wait的作用

它的逻辑是创建两个进程 子进程五秒后结束 父进程先休眠十五秒让子进程进入僵尸状态 当父进程休眠完毕之后使用wait函数回收子进程 之后打印出父进程回收的结果

  1 #include <stdio.h>
  2 #include <unistd.h>
  3 #include <stdlib.h>
  4 #include <sys/wait.h>
  5 #include <sys/types.h>
  6 // 演示wait函数的作用
  7 int main()
  8 {
  9   int ret = fork();
 10   if (ret == 0)
 11   {
 12     // child
 13     int count = 5;
 14     while(count--)
 15     {
 16       printf("hello world!\n");
 17       sleep(1);
 18     }
 19 
 20     exit(0); // 子进程退出
 21   }                                                                                                               
 22 
 23   // father
 24   sleep(15);
 25 
 26   pid_t id = wait(NULL);
  27   if (id > 0)
 28   {
 29     printf("wait success!\n");
 30   }
 31 
 32   sleep(10);
 33   return 0;
 34 }

下面是这段代码的执行结果

可以看到我们等待成功了

waitpid

waitpid和wait函数的作用差不多 都是等待一个子进程结束

它的函数使用方法如下

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

它们的返回值是完全一样的 如果等待成功会返回等待进程的pid 如果等待失败则返回-1

这个函数具有三个参数

我们下面一个个介绍它们的作用

pid_t pid

此项参数需要我们填入一个子进程的pid来指定等待该子进程结束

如果我们想等待任意进程都可以 这里可以填-1

int* status

此项参数需要我们填入一个地址

它是一个输出型参数 当我们填入一个地址后该函数会在该地址处写入子进程的退出状态

如果我们不关心这个退出状态 这里可以填写null

int options

此项参数需要我们填入选项

如果我们想要父进程一直等待子进程结束 则可以填入0 （阻塞等待）

如果我们只想父进程问一次子进程有没有结束 则可以填入WNOHANG （非阻塞等待）

status详解

注意： 我们这里只研究的status低16位！

status是一个整型变量 但是我们不能单独的把它看作一个整型

分别三个部分研究更合适

1. 高八位表示的是退出状态 即我们的退出码
2. 低七位表示的是终止信号 如果我们的进程被信号所杀则此处会有终止信号
3. 第八位表示的是core dump表示 这个我们暂时不需要了解

所以说我们只需要通过一系列的位操作就能够获取到位信号

exitCode = (status >> 8) & 0xFF; //退出码
exitSignal = status & 0x7F;      //退出信号

linux中提供了两个宏来让我们获取退出码和退出信号

它们分别是

• WIFEXITED(status)：用于查看进程是否是正常退出 本质是检查是否收到信号
• WEXITSTATUS(status)：用于获取进程的退出码

我们可以写出两段代码来运用下它们

运行后结果和预期一致

阻塞和非阻塞详解

我们下面通过一个小故事 来讲解阻塞和非阻塞的概念

假如现在是期末复习阶段 明天就要考试了 你却完全没有复习
你的一个朋友张三 它复习的特别好 你想要去找他要复习资料
现在你来到张三的宿舍楼下 打电话给张三 让他下来请他去吃个饭 顺便要一下复习资料
张三电话里回复你说 现在还不太方便 还要30分钟才能下楼
假设你现在跟张三说 那你先别挂电话了 我在下面一直等着你 然后你就一直等着 什么事情都不做 这就叫做阻塞等待
假设你现在跟张三说 那你先忙 我先玩会儿游戏 然后你就去打游戏 每隔五分钟再打个电话问张三有没有好 这就叫做非阻塞等待

多进程等待模型

上面的代码都是一个父进程创建了一个子进程

但是事实上我们的一个父进程可以创建多个子进程并且可以等待它们退出

这个叫做多进程的创建和等待的代码模型

代码表示如下

简单描述下上面的代码

我们创建了十个子进程 并且每个子进程的退出码都不一样

之后我们使用父进程根据储存的子进程pid一个个的等待回收并且接受它们的status

分析出来它们的exit code

演示结果如下

非阻塞轮询模型

我们前面讲过 父进程的等待分为阻塞等待和非阻塞等待

而阻塞等待的时候我们的父进程是做不了任何事情的 这也是移动十分浪费效率的方式

所以说我们平时推荐大家使用非阻塞轮询方式

我们只需要将waitpid的第三个参数改为WNOHANG就可以了

下面是代码示例

简单介绍下这段代码

首先这段代码会创建一个子进程 这个子进程会休眠十五秒

父进程会使用非阻塞模式来查询这个子进程有没有死亡

如果返回的结果是0（子进程还在执行）那么父进程就会做自己的事情一秒钟 一秒钟之后再来问

运行结果如下

进程替换

进程替换是什么

我们在执行一个进程的时候 可能想要这个进程去执行其他程序的代码 我们使用进程替换函数替换当前进程的数据段和代码段的过程就叫做进程替换

为什么要进行进程替换

因为这个进程跑完一部分之后我们想要调用另外一个程序 或者说要使用多种语言执行任务的时候需要用到进程替换

进程替换的原理

用fork创建子进程后 子进程执行的是和父进程相同的程序（但有可能执行不同的代码分支） 若想让子进程执行另一个程序 往往需要调用一种exec函数

当我们调用函数之后该进程的数据段和代码段全部被替换

并且重载程序计数器 让它从新程序的开头开始执行

当新程序重载时 有没有创建新的进程

答案是否定的 因为新程序的重载仅仅是替换了物理内存的数据段和代码段 并没有改变PCB和mm_struct 所以说并没有创建新的内存 内存的pid还是和原来一样的

当子进程进行程序替换后 会不会影响父进程

不会 虽然说子进程和父进程的数据段和代码段大部分是共享的 但是如果我们修改了子进程的数据段和代码段此时便会发生写时拷贝 从而保证进程之间的独立性

如何进行进程替换

我们可以使用进程替换函数来进行进程替换

我们下面直接写出一个替换函数的使用代码 在初步了解如何使用之后再做详细的讲解

代码如下

解释下上面的代码

首先会打印一句话 进程正在运行

接着我们会替换进程为 ls 理论上来说 我们后面的语句也不会打印了

事实上也符合我们的预期

大概了解进程替换函数是怎么一个效果之后我们来了解它们的具体使用

六大替换函数详解

因为所有的替换函数都是以exec开头的函数 它们统称为exec函数

exec函数的返回值

我们都知道 进程的替换有成功和失败两种情况 所以说它的返回值我们也要分两种情况讨论

如果进程替换失败则返回 -1 这个时候可以让我们的被替换的进程知道替换没有成功 从而能够决定下一步怎么走

如果进程替换成功则没有返回值 因为进程替换成功之后原来的进程事实上就不存在了 返回一个值没有任何的意义

对于exec函数来说它们的返回值都遵循我们上面的原则 所以对于下面的函数我们就只讨论它们的参数了

execl

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

我们先看这个函数的名字 相比我们的exec多了一个l

这个l其实就是列表的意思 意味着它的参数要使用列表的形式传入

它的第一个参数是 const char *path 它代表着要执行程序的路径

它的第二个参数是 const char *arg, ... 它代表着可变参数列表 是使用NULL结尾的

例如我们要执行ls程序的话 就可以写出下面的代码

 execl("/usr/bin/ls" , "ls" , "-a" , "-i" , NULL);

execlp

int execlp(const char *file, const char *arg, ...);

我们先看这个函数的名字 相比我们的exec多了一个l 多了一个p

p代表的是path 路径 意味着这个函数能够自动推导路径

它的第一个参数是 const char *file 它代表着要执行的程序名

它的第二个参数是 const char *arg, ... 它代表着可变参数列表 是使用NULL结尾的

例如我们要执行ls程序的话 就可以写出下面的代码

 execlp("ls" , "ls" , "-a" , "-i" , NULL);

execle

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

我们首先看这个函数的名字 相比我们的exec多了一个l 多了一个e

多了的这个e意味着它可以自己配置一个环境变量 我们在自己的函数内部就可以使用我们配置的这个环境变量

它的第一个参数是const char *path 它代表着要执行程序的路径

它的第二个参数是 const char *arg, ... 它代表着可变参数列表 是使用NULL结尾的

它的第三个参数是 *const envp[] 它代表着一个数组 数组里面是我们自己配置的环境变量

例如 我们可以自己设置一个env环境变量 并在我们的程序中使用它

char* envp[] = { "val", NULL };
execle("./mycmd", "mycmd", NULL, envp);

execv

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

我们先看这个函数的名字 相比我们的exec多了一个v

这个v我们可以将它理解为vector 数组的意思 我们传递的参数要以数组的形式传递

它的第一个参数是 const char *path 它代表着要执行程序的路径

它的第二个参数是 char *const argv[] 它代表着一个数组 我们将要执行的命令放在数组中并且以null结尾

例如我们要执行ls程序的话 就可以写出下面的代码

char* myargv[] = { "ls", "-a", "-i", NULL };
execvp("/usr/bin/ls", myargv);

execvp

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

我们先看这个函数的名字 相比我们的exec多了一个vp

这个v我们可以将它理解为vector 数组的意思 我们传递的参数要以数组的形式传递

p代表的是path 路径 意味着这个函数能够自动推导路径

它的第一个参数是 const char *file 它代表着要执行的程序名

它的第二个参数是 char *const argv[] 它代表着一个数组 我们将要执行的命令放在数组中并且以null结尾

例如我们要执行ls程序的话 就可以写出下面的代码

char* myargv[] = { "ls", "-a", "-i", "-l", NULL };
execvp("ls", myargv);

execve

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

我们先看这个函数的名字 相比我们的exec多了一个vc

这个v我们可以将它理解为vector 数组的意思 我们传递的参数要以数组的形式传递

这个e意味着它可以自己配置一个环境变量 我们在自己的函数内部就可以使用我们配置的这个环境变量

例如 我们可以自己设置一个env环境变量 并在我们的程序中使用它

char* myargv[] = { "mycmd", NULL };
char* env[] = { "val", NULL };
execve("./mycmd", myargv, env);

替换函数的命名理解

这六个替换函数都是以 exec开头的 我们可以根据它们最后的1~2两个字符来理解它们的参数

• l （list） 意味着它的参数要使用列表的形式传入以NULL结尾
• v (vector) 我们传递的参数要以数组的形式传递
• p (path) 表示能自动搜索环境变量PATH
• e (env) 表示可以传入自己设置的环境变量

事实上其实只有execve才是真正的系统调用 其他的函数都是根据execve封装而来的

思维导图总结