深入了解linux系统—— 进程控制
进程创建
fork函数
在Linux操作系统中，我们可以通过fork函数来创建一个子进程；
这是一个系统调用，创建子进程成功时，返回0给子进程，返回子进程的pid给父进程；创建子进程失败则返回-1给父进程。
我们就可以通过返回值来对父子进程进行分流：
#include <stdio.h>
#include <unistd.h>
int main()
{int id = fork();if(id < 0){//创建子进程失败perror("fork");return 1;}else if(id == 0){//子进程printf("子进程, pid : %d\n",getpid());}else{//父进程printf("父进程, pid : %d\n",getpid());}return 0;
}
使用fork函数创建子进程，这里简单复习一下就OK了；
我们来看通过fork创建子进程，操作系统内核做了什么：
- 首先就是分配新的内存块和内核数据结构给子进程
- 然后就是将父进程部分数据结构内容拷贝给子进程
- 将子进程添加到系统进程列表当中
fork返回，调度器开始调度
这里fork之前我们的父进程独立执行，fork创建子进程之后，父子进程两个执行流就分别执行。
写时拷贝
我们知道，当创建子进程之后，父子进程的代码和数据是共享的，而当有一个进程(父进程/子进程)要进行数据修改时，我们的操作系统就会进行写时拷贝，重新开辟一块空间给这个进程，然后修改它的页表（虚拟地址和物理地址）的对应关系；这样就完成了写时拷贝。
那操作系统是如何知道一段代码和数据现在是共享的呢？
这个问题就比较简单了，在我们的页表中不仅存放了虚拟地址和物理地址的对应关系，还存在对这一块内存的权限（r、w等）
当我们通过
fork创建子进程之后，我们的父子进程共享代码和数据，操作系统就会将我们父子进程对代码和数据的权限修改为只读；当我们应该进程想要修改数据时，操作系统通过页表发现进程对数据的权限为只读，操作系统就会报错，然后给我们进程重新开辟一块空间，然后将数据拷贝过来，再修改我们进程页表的地址映射关系；
而写时拷贝之后，操作系统就会将我们父子进程对代码和数据的权限修改为可读可写。这样我们进程之间就不会相互影响了。
写时拷贝：是一种延时申请技术，可以提高整机内存的使用率
fork函数的常规使用
我们之前使用fork来创建子进程，然后让父子进程分流执行不同的代码，这是fork常规使用的一种，也就是：父子进程执行不同的代码段。
除此之外呢，我们还可以通过fork创建进程，然后通过调用exec系列函数，让子进程执行不同的程序。
- 创建子进程，让子进程执行不同的代码段
- 创建子进程，让子进程执行不同的程序
fork失败的原因
我们知道fork创建子进程成功，返回0给子进程，返回子进程的pid给父进程；而创建子进程失败则返回-1给父进程。
那fork为什么会失败呢？
简单来说就是：
- 系统中存在太多的进程
- 实际用户的进程数量超过了限制
进程终止
进程退出
在我们执行一个程序时，这个程序可能代码运行完了，且结果符合我们的预期；也可能代码运行完了，但是结果不符合我们的预期；当然也可能我们的程序代码根本就没有运行完，而是中途退出了。
所以进程退出，也就存在三种可能：
- 代码运行完，结果正确；
- 代码运行完，结果不正确；
- 代码异常终止；
进程常见退出方法
那我们知道了进程退出有三种可能；那我们进程如何退出呢？
- 从
main函数返回 exit函数_exit
当然我们使用Ctrl + C杀死一个进程属于进程的异常退出；通过信号让进程终止也属于异常退出。
exit函数
通过查看手册，可以发现exit函数是3号手册，也就是C标准库的库函数；
那它的作用就是，退出一个进程，然后并返回退出码；像我们之前在C中执行的exit(1)就是退出程序并返回1。
_exit系统调用
通过查看手册，我们发现_exit位于2号手册，也就是系统调用；
它的作用也是退出进程，并且返回退出码。
exit和_exit的区别
那这两个函数都是退出一个进程，那有什么不同之处呢？
首先，
_exit是操作系统提供的进程退出的函数，而exit是库函数，exit可以说是对_exit的封装，在进程退出之前做了一些其他的事情。这里直白一点，直接说了：
exit底层也会调用_exit函数，但是在调用_exit函数之前，还做了：
- 执行用户通过
atexit/on_exit定义的清理函数；- 关闭所有打开的流，所有缓存数据均被写入。（简单理解就是刷新缓冲区）
- 然后再调用
_exit。
这里我们不懂atexit/on_exit这些，但是我们好像知道缓冲区，现在来看下面代码，通过exit和_exit退出的区别：
#include <stdio.h>
#include <stdlib.h>
int main()
{printf("hello linux");exit(1);//_exit(1);return 0;
}
我们知道，在输出时，缓冲区是按行刷新的，这里我们输出hello linux没有换行，数据就在缓冲区当中；
return退出和exit退出的区别
我们知道在main函数中，return也是退出进程，exit也可以退出进程，那它们有什么区别呢？
在
main函数中，没有什么区别，都是进程退出；在其他函数中，
return是退出当前函数，而exit是直接退出进程。
退出码
退出码，它可以告诉我们最后一次执行的命令(程序)的状态；
我们可以使用echo $?来查看最近一次程序退出的退出码：
#include <stdio.h>
int main()
{return 1;
}
当程序退出时，退出码为
0通常表示程序执行成功，没有问题；如果退出码不是
0就认为程序运行不成功。
这里也要记住一个点：当程序异常终止时，程序的退出码是没有意义的。
进程等待
为什么要等待
- 在进程状态中，我们了解到了僵尸进程，但是我们只是知道子进程比父进程先退出，会造成子进程僵尸状态，但是我们并不知道如何去解决僵尸进程；（这里我们需要让父进程等待，去解决僵尸进程问题，且获取子进程退出时的退出信息）
- 此外，当一个进程进入僵尸状态，我们是无法杀死一个僵尸进程的；因为这个进程已经退出了，只不过保留了
task_struct等待父进程获取退出信息。 - 创建子进程是让子进程去执行父进程派给子进程的任务，在子进程退出后，无论是正常退出还是异常退出，都要让父进程知道子进程的运行结果。
所以我们要让父进程通过进程等待，来回收子进程的资源，获取子进程的退出信息。
如何等待
那我们如何让父进程等待呢？
通过系统调用wait和waitpid；
wait方法
wait只有一个参数，这个status是一个输出型参数，简单来说就是：我们想要让父进程获得子进程的退出信息，就传递一个int* 指针，这样在函数调用结束后，父进程就拿到了子进程的退出信息；（如果不需要获取子进程退出信息，可以传NULL）。
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>int main()
{int id = fork();if(id < 0)return 1;else if(id == 0){//子进程int cnt = 3;while(cnt--){printf("子进程, pid : %d, ppid : %d\n",getpid(),getppid());sleep(1);}exit(1);}//父进程sleep(5);wait(NULL);while(1){ }return 0;
}
看上述代码，我们让子进程循环进行三次，每次打印一句话，然后
sleep1秒钟；循环运行结束直接退出；父进程先
seep5秒钟，然后再进程等待wait（这里我们先不获取子进程退出信息，传NULL）。我们预期的结果是：子进程运行三秒，然后子进程退出，而我们的父进程先睡眠
5秒，所以子进程有两秒是处于僵尸状态的；在父进程睡眠结束时，进入等待，然后子进程结束僵尸状态。这里为了方便我们查看，父进程等到结束之后，我们让父进程进入死循环。
这里对于返回值，如果wait执行成功则返回子进程的pid给父进程，失败则返回-1给父进程。
waitpid方法
waitpid进程等待的方法，与wait不同的是：waitpid多了两个参数：pid和option；
首先是pid
这里我们主要就看
-1和<0的部分：
-1：当我们传-1时，就表示我们当前父进程要等待任意个子进程结束。
>0：我们父进程等待某一个子进程时，我们可以传子进程的pid，让父进程等待某一个子进程
现在来看waitpid的第三个参数：options
options参数默认为0，它表示阻塞等待；什么意思呢？简答来说，就是父进程在调用
waitpid时，如果要等待在子进程还没有结束，那父进程就在waitpid中阻塞掉，直到子进程退出，waitpid再返回。而我们也可以传
WNOHANG，当我们传WNOHANG时，如果要等待的子进程还没有结束，waitpid就直接0，我们的父进程不会在waitpid中阻塞掉；如果子进程结束，那就返回子进程的pid。
这里举个例子：
最近周末，你要和女朋友出去旅游，现在要出发了，你已经准备好了，你来到了女朋友的宿舍楼下，要等你女朋友下楼；
你给她打了电话过去，询问她好了没有，她说没有，然后你就挂了；拿起手机玩起来了游戏了；玩了一局游戏，你又给你女朋友打了过去，然后她说还没有，然后你又挂了，又开了一局游戏。打完又给你女朋友打去了电话询问她好没好，她是快了马上，说让你不用挂电话，她准备好了给你说。
然后你没有挂电话，就拿着手机等待你女朋友给你说她准备好了。
这里你打一次电话询问你女朋友好了没有，没有然后你就挂了电话；这本质上不就是一次非阻塞等待吗。（你女朋友没有好，然后你就挂了电话）
而当你打电话询问你女朋友好了没有，知道了没有你并没有挂断电话，而是拿着手机等待你女朋友准备好。这不就是一次阻塞等待吗。
而体现到我们父进程等待上面就是，父进程调用
waitpid，如果子进程没有结束，waitpid没有返回，而是等待子进程退出后再返回，再次期间父进程就阻塞在了waitpid中；这不就是阻塞等待吗。而父进程调用
waitpid，如果子进程没有结束，函数直接返回0，父进程可以去做自己的事情，这不就是非阻塞等待吗。
阻塞等待这里就不演示了，现在看一下非阻塞等待：
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{int id = fork();if(id == 0){//子进程int cnt = 3;while(cnt--){printf("子进程, pid : %d, ppid : %d\n",getpid(),getppid());sleep(1);}exit(1);}//父进程printf("wait begin\n");while(waitpid(-1,NULL,WNOHANG) == 0){printf("父进程: pid : %d\n",getpid());sleep(1);}printf("wait end\n");sleep(10); return 0;
}
一般情况下，我们使用非阻塞调用要轮循调用waitpid，再等待过程中，父进程可以执行自己的代码（比如要完成一个或多个任务）。
获取子进程的status
在上述中，我们进程等待解决了僵尸进程的问题；但是我们进程等待不止可以解决子进程的僵尸问题，还可以让父进程获取子进程的退出信息。
在上述中，我们没有获取子进程的退出信息，所以传的参数是
NULL，现在我们来获取一下子进程的退出信息。
我们先来看以下代码：
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{int id = fork();if(id < 0)return 1;else if(id == 0){//子进程printf("子进程, pid : %d, ppid : %d\n",getpid(),getppid());exit(1);}//父进程int status = 0;wait(&status);//阻塞等待//waitpid(-1,&status,0);printf("child status : %d\n",status);return 0;
}
我们发现，我们子进程的退出码是
1，但是我们拿到的status是256；这是为何？
这是因为，虽然status是类型是int；但是我们不能将它当做一个整形来看待，而是当做一个位图；
int类型4字节，也就是32个bit位；我们要将这32个bit位划分成以下三部分：
其中，高
16位没有使用，我们不考虑而使用到的低
16位中的高8位表示进程退出时的退出码；低8位表示进程的退出信号
退出码：
先来看退出码的区域：
退出信号：
现在来看退出信号部分，在退出信号部分中，还存在着一个标识位core dump；
这里注意：如果进程是异常退出（被信号杀死），那它的退出码就没有任何意义了。
就好比考试作弊被发现了，考试成绩就没有意义了。
进程异常退出，程序都没有执行完，那退出码就没有什么意义了。
我们了解了status，那我们如果想要通过status获得进程的退出码或者退出信号呢？
这里就要涉及到位操作了；
在获取退出码和退出信号之前，我们要先判断一下进程是否是被信号杀死的。
我们只需判断
status按位与上ox7F（0111 1111)，判断退出信号是否为0即可（因为没有0号信号）。
首先获取退出码：
我们只需让
status>>8然后再按位与&上0xFF（1111 1111）即可获得退出码。
获取退出信号：
在上述中其实已经描述了，
status按位与&上0x7F（0111 1111）即可获得进程退出信号。如果进程退出信号为
0那就表示进程是正常退出的，因为不存在0号信号。
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{int id = fork();if(id < 0)return 1;else if(id == 0){//子进程printf("子进程, pid : %d, ppid : %d\n",getpid(),getppid());exit(1);}//父进程int status = 0;wait(&status);printf("child status : %d\n",status);printf("status exit code : %d\n",(status)&0xFF);printf("status exit signal : %d\n",status&0x7F);return 0;
}
可以看到，这样我们的确获得了进程的退出码和退出信息。
当然在操作系统中还存在一些宏，我们可以直接使用这些宏来获取退出码和退出信息：
退出码：
WIFEXITED(status)：判断程序是否正常退出；返回
true就表示程序正常退出；
WEXITSTATUE(status)：当进程正常退出时，可以通过WEXITSTATUE获取进程的退出码。退出信号：
WTERMSIG(status)：当进程异常退出时，可以使用WTERMSIG获取当前进程的退出信号。
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{int id = fork();if(id < 0)return 1;else if(id == 0){//子进程printf("子进程, pid : %d, ppid : %d\n",getpid(),getppid());exit(1);}//父进程int status = 0;pid_t rid = wait(&status);if(WIFEXITED(status)){//进程正常退出printf("wait succes,rid : %d, exit code : %d\n",rid,WEXITSTATUS(status));}else{ //进程异常退出printf("status exit signal : %d\n",WTERMSIG(status));} return 0;
}
进程切换
在我们之前创建子进程时，我们创建的子进程执行的代码，都是父进程代码的一部分；
如果我们想要让我们子进程执行不同的代码，执行新的程序呢？
此时，我们就要一个进程切换，让子进程执行新的程序；
先来看一段进程切换的简单代码：
#include <stdio.h>
#include <unistd.h>
int main()
{printf("进程切换 begin\n");execl("/usr/bin/ls","ls","-a","-l",NULL);printf("进程切换 end\n");return 0;
}
原理
程序替换是通过特定的接口，加载磁盘上的一个全新的程序（代码和数据）然后让进程执行全新的程序。
听起来进程替换好高级，但是它是如何实现的呢？
当我们的一个进程想要进行进程切换时，原理非常简单，就是将磁盘中全新的程序(代码和数据)覆盖式的加载到当前程序代码和数据的位置，然后修改页表即可。
而我们如果是子进程想要进行进程切换：
我们知道当我们父进程通过
fork创建子进程时，操作系统会给子进程分配新的内存块和内核数据结构给子进程，然后将父进程的部分数据结构内容拷贝到子进程中，其中就包含进程地址空间，以及页表；这样我们父子进程就指向同一个代码和数据；那我们现在要进行进程替换，也就是修改子进程指向的代码；
此时操作系统就会报错，发生写时拷贝，给子进程重新开辟一块空间，然后将新的程序的（代码和数据）加载到这块空间内，然后让子进程指向这一块新的空间，并修改页表；
这样就完成了子进程的程序替换。
替换函数
理解了进程切换的原理，我们现在来看进程切换exec系列函数。
exec系列函数一共有6个，记起来非常麻烦；但是这些命名都是有规律的。
注意：exec系列函数如果替换成功是没有返回值的，因为替换成功之后，我们原来代码后面的部分就不会被执行了。
如果替换失败，则返回-1
命名规律
l(list)：表示参数使用列表的形式(可变参数列表)v(vector)：表示参数使用数组的形式p(path)：表示可以自动去PATH环境变量的路径中找对应指令（简单来说就去执行系统命令不需要带路径）。e(env)：表示环境变量表；
现在来依次看一下这些函数的简单使用：
execl
execl函数参数存在两个
- 一个表示要执行新的程序所在的路径
- 另一个则是参数列表，表示要怎们执行这个新的程序
execl函数命名只有l表示以参数列表的形式调用，执行系统指令时也要带上路径。注意：参数列表要以
NULL结尾；（命令行参数表以NULL结尾）
执行系统命令
#include <stdio.h>
#include <unistd.h>
int main()
{printf("replace begin\n");execl("/usr/bin/ls","ls","-a","-l",NULL);printf("replaxe end\n");return 0;
}
执行自己写的程序（这里我们自己写一个程序，输出一下命令行参数）
//test.c
#include <stdio.h>
int main(int argc, char* argv[])
{for(int i = 0;i < argc;i++){printf("argv[%d] : %s\n", i, argv[i]);}return 0;
}
//code.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types>
#include <sys/wait.h>
int main()
{printf("replace begin\n");execl("./test","./test","-a","-b","-c",NULL);printf("replaxe end\n");return 0;
}
execlp
这个函数就非常简单了，和execl相比唯一的不同就是，执行系统指令时不需要带路径（会通过PATH环境变量去寻找）
#include <stdio.h>
#include <unistd.h>
int main()
{execl("ps","ps","-a","-l",NULL);return 0;
}
当然使用
execlp也可以执行自己写的程序，不过要带上路径。
execle
这个函数就存在三个参数了：
- 新的程序所在的路径（系统指令也要带路径）
- 参数列表，以
NULL结尾- 环境变量表。
我们知道全局变量
environ它执行环境变量表，所以我们如果不使用我们自己的环境变量表，传environ即可。
这里我们让test输出一下环境变量表
//test.c
#include <stdio.h>
int main(int argc, char* argv[], char* env[])
{for(int i = 0; env[i];i++){printf("env[%d] : %s\n",i,env[i]);}return 0;
}
#include <stdio.h>
#include <unistd.h>
int main()
{extern char** environ;execle("./test","./test",NULL,environ);return 0;
}
execv
execv第一个参数和execl相同，这里就不描述了；
看第二个参数：char* const argv[]，简单来说就是指针数组；也就是命令行参数表；
(注意：这里的命令行参数列表要以NULL结尾)
#include <stdio.h>
#include <unistd.h>
int main()
{char* const argv[] = {(char* const)"ls",(char* const)"-a",(char* const)"-l",NULL};execv("/usr/bin/ls",argv);return 0;
}
execvp
execvp和execv的区别就是，在执行系统命令时，我们可以不带路径；execvp会在环境变量PATH中找指定程序。
#include <stdio.h>
#include <unistd.h>
int main()
{char* const argv[] = {(char* const)"ls",(char* const)"-a",(char* const)"-l",NULL};execpv("ls",argv);return 0;
}
execvpe
execvpe存在三个参数，file、argv和env
file：第一个参数，和上面一样，指的是程序所在的路径。
argv：第二个参数指的是命令行参数表。
env：第三个参数指的是环境变量表。
这里我们还是使用test来测试，让test输出命令行参数表和环境变量表；
//test.c
#include <stdio.h>
int main(int argc, char* argv[], char* env[])
{for(int i = 0;i < argc;i++){printf("argv[%d] : %s\n", i, argv[i]);}printf("\n");for(int i = 0; env[i];i++){printf("env[%d] : %s\n",i,env[i]);}return 0;
}
//code.c
#include <stdio.h>
#include <unistd.h>
int main()
{char* const argv[] = {(char* const)"./test",(char* const)"-a",(char* const)"-b",(char* const)"-c",NULL};//使用自己的环境变量表char* const env[] = {(char* const)"I=LXB",(char* const)"MYVAL=666",NULL};execvpe("./test",argv,env);//extern char** environ;//execvpe("ls",argv,environ);return 0;
}
这里也可以执行系统指令，不需要带路径
这里简单总结一下这些函数：
| 函数名 | 路径 | 参数格式 | 环境变量表 |
|---|---|---|---|
execl | 需要带路径 | 列表 | 使用当前环境变量表 |
execlp | 系统命令不需要带路径 | 列表 | 使用当前环境变量表 |
execle | 需要带路径 | 列表 | 可以使用自己的环境变量表 |
execv | 需要带路径 | 数组 | 使用当前环境变量表 |
execvp | 系统命令不需要带路径 | 数组 | 使用当前环境变量表 |
execvpe | 系统命令不需要带路径 | 数组 | 可以使用自己的环境变量表 |
execve函数
与上面的exec系列的函数不同，execve是一个系统调用
这里简单来说上面的exec系列是库函数，而execve是操作系统提供的系统调用；
exec系列函数对系统调用做了封装；
那也就是说，我们使用
execlp、execvp执行系统命令不带路径时，最后也会调用execve时也会带上路径吗？我们在使用
execl、execv等，不传递环境变量表时，最后调用execve也会传递当前环境变量表吗？我我们在使用
execl系列时，传递的参数列表，也会被转化为参数数组，然后传递给execve吗？
对的，当我们使用execlp执行系统命令不带路径时，execl会根据环境变量PATH找到对应程序的路径，然后调用execve传程序的路径。
当我们使用execl、execv等没有传环境变量表时，exec系列在调用execve系统调用时会传当前环境变量表environ。
当我们使用execl系列，传递的参数列表，都会被转化成参数数组，然后再将参数值数组传递给execve。
到这里，本篇文章内容就结束了，干货满满！！！
简单总结：
进程创建
fork进程退出，退出时的退出码
进程等待
解决僵尸进程的问题；
获取子进程退出时的退出信息
退出信息
status进程切换：原理
exec系列函数
感谢各位的支持！