进程控制（Linux）
进程控制
- 进程创建
-
- fork函数
- fork函数返回值
- 写时拷贝
- fork常规用法
- fork调用失败的原因
- 进程终止
-
- 进程退出情况
- 进程等待
-
- 进程等待的必要性
- 进程等待的方法
-
- 获取子进程status
- 1、wait
- 2、waitpid方法
- 进程替换
-
- 替换原理
- 替换函数
- 函数解释
- 总结
- 我们可以综合前面的知识，做一个简易的shell
-
- 总结
进程创建
进程创建有两种方式：
1、命令行启动（程序、指令等）
2、通过程序自身，fork创建子进程
fork函数
它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程
#include 所有 fork 出来的子进程，都是以父进程为模板的。很多代码、数据都是继承父进程。
进程调用fork，当控制转移到内核中的fork代码后，内核做：
1、分配新的内存块和内核数据结构给子进程
2、将父进程部分数据结构内容拷贝至子进程
3、添加子进程到系统进程列表当中
4、fork返回，开始调度器调度
所以创建子进程，本质是OS多了一个进程，多了一套与进程相关的数据结构，以父进程为模板。
在不写入的情况下，用户的代码和数据是父子共享的。
关于 fork ，这里有两个问题？
1、为什么 fork 会有两个返回值？fork 返回值会返回两次？
2、一个变量里，怎么会有两个不同的值，从而让父子进程执行不同的业务逻辑？
因为fork函数的整个过程是由父进程做的，此时发生了写时拷贝，父子页表数据映射到了不同的内存区域，使父子进程数据各自私有一份，此时返回值写入变量id，就会有两个不同的返回值，一个是子进程创建成功返回 0 ，一个是父进程返回子进程的 id。
fork之后，父子两个执行流就分别执行，谁先执行，由调度器决定。
fork函数返回值
子进程返回0，
父进程返回的是子进程的 pid
写时拷贝
那么为什么要有写时拷贝？
保证父子进程的 “ 独立性 ”
写时拷贝的特点
1、强调是数据的写时拷贝，那么只拷贝需要写入的数据，不拷贝只读的数据，不去浪费系统内存和系统资源
2、fork时，会创建数据结构，为了提高fork的效率，不需要在去拷贝只读的数据
3、fork本身要向系统要更多的资源，当然越少，fork更容易成功
fork常规用法
1、一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求。
2、一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数。
fork调用失败的原因
1、系统中有太多的进程
2、实际用户的进程数超过了限制
进程终止
进程退出情况
1、代码运行完毕，结果正确。退出码 0
2、代码运行完毕，结果不正确。逻辑问题，退出码 !0
3、代码异常终止，程序崩溃了。（野指针、/0、越界…）
那什么是退出码？
退出码，可以人为的定义，也可以使用系统的错误码 list 计算机错误码 list 将int（整形）转换成string（错误码描述）
#include
进程退出的三种情况都应该是父进程应该关心的，需要知道子进程退出的结果，需要关心它的退出码。
实际子进程退出，父进程可以关心，也可以不关心子进程的运行结果。我们这里谈论的是父进程关心子进程的运行结果。
正常终止（可以通过 echo $? 查看进程退出码）：
- 从main返回
- 调用exit
- _exit
异常退出：
ctrl + c，信号终止
1、从main返回
main函数的return 0 表示终止进程
非main函数的return不是终止进程，而是结束函数
#include
2、调用exit
#include
void exit(int status);
任何函数使用exit，都表示终止进程
3、_exit
#include
void _exit(int status);
参数：status 定义了进程的终止状态，父进程通过wait来获取该值
第2、3种情况总结：
exit：在退出的时候，会进行后续资源处理，并且会刷新缓冲区
_exit：在退出的时候，不会进行后续资源处理，直接终止进程
exit做的其他工作：
- 执行用户通过 atexit或on_exit定义的清理函数。
- 关闭所有打开的流，所有的缓存数据均被写入
- 调用_exit
return退出
return是一种更常见的退出进程方法。执行return n等同于执行exit(n),因为调用main的运行时函数会将main的返 回值当做exit的参数
以上的铺垫都是为了，站在OS的角度，理解进程终止！！！
OS的角度理解：核心思想，归还资源
1、“释放” 曾经管理进程所维护的所有的数据结构对象
释放的意思：不是真的把数据结构对象销毁，而是设置为不用状态，然后保存起来，如果不用的对象多了，就有一个“数据结构的池”。
2、释放程序代码和数据占用的内存空间
不是代码和数据清空，而是把内存设置为无效
3、取消曾经该进程的连接关系
进程等待
进程等待的必要性
进程等待的必要性也就是为什么要等待？等待谁？
当fork之后会创建子进程，如果子进程挂掉或者退出，父进程不管的话，就会变成僵尸进程，一直存在系统中，从而造成内存泄漏。变成僵尸进程，就是杀不死的状态，kill -9也无能为力，因为无法去杀掉一个已经死了的进程。所以父进程要知道子进程是正常退出，还是运行完成，结果的对与不对。
所以为什么要等待，等待子进程？
1、回收僵尸进程，解决内存泄漏
2、需要获取子进程的运行结束状态 - 这点不是必须的
3、父进程要尽量晚于子进程退出，可以规范化进行子进程的资源回收、处理业务
进程等待的方法
获取子进程status
- wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。
- 如果传递NULL，表示不关心子进程的退出状态信息。
- 否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
- status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）
ExitCode = (status >> 8) & 0xFF;//退出状态（退出码）高八位
ExitSignal = (status & 0X7F;//退出信号 低7位
系统当中也提供了两个宏来获取退出状态和退出信号
- WEXITSTATUS(status)：用于获取进程的退出状态（退出码）
- WIFEXITED(status)：用于查看进程是否是正常退出，本质是检查是否收到信号。
1、wait
#include
#include
pid_t wait(int*status);
返回值：
成功返回被等待进程pid，失败返回-1。
参数：
输出型参数，获取子进程退出状态,不关心则可以设置成为NULL
1 #include <sys/wait.h>
2 #include <stdio.h>
3 #include <stdlib.h>
4 #include <string.h>
5 #include <errno.h>
6 int main( void )
7 {
8 pid_t pid = fork();
E> 9 if ( pid == -1 )
10 perror("fork"),exit(1);
11 if ( pid == 0 ){
12 int count = 5;
13 while(count--)
14 {
E> 15 printf("child is running, ppid: %d pid: %d\n",getppid(), getpid());
E> 16 sleep(1);
17 }
18 exit(10);//终止子进程
19 } else {
20 printf("father is waiting!!!\n");
21 int st;
22 int ret = wait(&st);//先不关心退出的状态
23 if ( ret > 0 && (st & 0x7F) == 0){ // 正常退出
24 printf("child exit code：%d\n",(st>>8)&0xFF);
25 }
26 else if( ret > 0 ) { // 异常退出
27 printf("sig node：%d\n",st&0x7F);
28 }
29 }
30 }
父进程一直在等待（等待任意一个子进程），当子进程退出后，wait就可以返回，此时父进程就可以拿到子进程的退出码
这里父进程等待成功，成功拿到子进程的退出码
下面来看库函数中的方法拿到退出码和退出信号
2、waitpid方法
pid_ t waitpid(pid_t pid, int *status, int options);
返回值：
- 当正常返回的时候waitpid返回收集到的子进程的进程ID；
- 如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0；
- 如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在；
参数：
pid： - Pid=-1,等待任一个子进程。与wait等效。
- Pid>0.等待其进程ID与pid相等的子进程。
status:
- WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）
- WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）
options:
- WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。
1、如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退出信息。
2、如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞。
3、如果不存在该子进程，则立即出错返回
一、当options为0的时候，进程等待为阻塞等待
阻塞等待也就是上面刚刚的例子，父进程等待子进程执行完毕退出后，才会执行父进程。
子进程退出后，但PCB即相关的内核数据结构没有删除，退出码保存在数据结构中，wait拿取到当前子进程的退出码，所以父进程知道子进程已退出。
1 #include <sys/wait.h>
2 #include <stdio.h>
3 #include <stdlib.h>
4 #include <string.h>
5 #include <errno.h>
6 int main( void )
7 {
8 pid_t pid;
E> 9 if ( (pid=fork()) == -1 )
10 perror("fork"),exit(1);
11 if ( pid == 0 ){
12 int count = 5;
13 while(count--)
14 {
E> 15 printf("child is running, ppid: %d pid: %d\n",getppid(), getpid());
E> 16 sleep(1);
17 }
18 exit(10);//终止子进程
19 } else {
20 printf("father is waiting!!!\n");
21 int st;
22 pid_t ret = waitpid(pid, &st, 0);
23 if (ret >= 0){
24 printf("wait child success...\n");
25 if (WIFEXITED(st)){
26 printf("exit code: %d\n", WEXITSTATUS(st));
27 }
28 else{
29 printf("killed by siganl %d\n", WIFEXITED(st));
30 }
31 }
E> 32 sleep(5);//5 seconds after exit
33 }
34 }
没有杀死子进程的情况下可以获取到退出码，我们在来看看杀死子进程，父进程是否还能获取子进程的退出码
上面两点说明了什么？
1、使用waitpid可以检测子进程的一个状态，子进程尽管被杀死也可以被父进程检测出来，从而让OS进行回收，也就不会导致子进程变成杀不死的僵尸进程了，也不会浪费系统资源。
2、被信号杀死而退出的子进程，其退出码将没有任何意义。
二、多进程创建以及等待
同时创建多个子进程，然后让父进程依次等待子进程退出
监控脚本
[dy@VM-12-10-centos process_control]$ while :; do ps axj | head -1 && ps axj | grep tuichuma | grep -v grep;echo "######################";sleep 1;done
#include 
三、基于非阻塞的轮流检查方案
- WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。
当子进程未退出时，父进程都在一直等待子进程退出，在等待期间，父进程不能做任何事情，这种等待叫做阻塞等待
我们可以不断去检查子进程的状态，当子进程未退出时，父进程可以做一些自己的事情，这种等待叫做非阻塞等待
1 #include <stdio.h>
2 #include <unistd.h>
3 #include <stdlib.h>
4 #include <sys/wait.h>
5 int main()
6 {
7 pid_t pid = fork();
8 if(pid < 0){
9 printf("%s fork error\n",__FUNCTION__);
10 return 1;
11 }else if( pid == 0 ){ //child
12 printf("child is run, pid is : %d\n",getpid());
13 sleep(5);
14 exit(1);
15 } else{
16 int status = 0;
17 pid_t ret = 0;
18 do
19 {
20 ret = waitpid(-1, &status, WNOHANG);//非阻塞式等待
21 if( ret == 0 ){
22 printf("child is running\n");
23 }
24 sleep(1);
25 }while(ret == 0);
26 if( WIFEXITED(status) && ret == pid ){
27 printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status));
28 }else{
29 printf("wait child failed, return.\n");
30 return 1;
31 }
32 }
33 return 0;
34 }
父进程每隔一段时间就会去检测子进程的情况，其他时间做自己的事，直到子进程退出，此时等待成功。
进程替换
替换原理
1、用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支)
2、子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。
3、调用exec并不创建新进程,所以调用exec前后该进程的id并未改变
子进程进行进程程序替换后，会影响父进程的代码和数据吗？
子进程刚被创建时，父子进程共享代码和数据，当子进程要对代码和数据进行写入时，此时发生写时拷贝，进行程序替换后，并不会影响服进行的代码和数据。
那怎么进行程序替换，此时就要用到系统的exec等一系列函数。
替换函数
其实有六种以exec开头的函数,统称exec函数:
#include 1 #include <unistd.h>
2 #include<stdio.h>
3 #include<stdlib.h>
4 int main()
5 {
W> 6 char *const argv[] = {"ps", "-ef", NULL};
W> 7 char *const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL};
8 execl("/bin/ps", "ps", "-ef", NULL);
9 // 带p的，可以使用环境变量PATH，无需写全路径
10 execlp("ps", "ps", "-ef", NULL);
11 // 带e的，需要自己组装环境变量
12 execle("ps", "ps", "-ef", NULL, envp);
13 execv("/bin/ps", argv);
14 // 带p的，可以使用环境变量PATH，无需写全路径
15 execvp("ps", argv);
16 // 带e的，需要自己组装环境变量
17 execve("/bin/ps", argv, envp);
18 exit(0);
19 return 0;
20 }
函数解释
- 这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。
- 如果调用出错则返回-1
- 所以exec函数只有出错的返回值而没有成功的返回值
下面是运行结果，通过execl函数我们可以得到 ls -a -l -i 的运行结果。
到这里，有的小伙伴就要问了，其他exec函数也可以吗？当然是可以的！！！
这里的execlp函数带p会自动搜索环境变量，也就不需要添加路径
细心的小伙伴，应该已经发现，第二个printf函数没有打印。
1、这里程序已经替换了，所以不会在去执行exec* 函数后面的程序。
2、exec* 只要返回了就说明出错了
以上都是对系统指令程序的运行，那么我们可以执行自己的程序嘛？
当然是可以的，不过我们先来看一下Makefile的小知识，如何一下编译两个程序
osexe.c：
1 #include<stdio.h>
2 #include<unistd.h>
3 #include <stdlib.h>
4 #include<sys/wait.h>
5 int main()
6 {
7 pid_t id = fork();
8 if(id == 0)
9 {
10 printf("child fork success, getppid: %d, getpid: %d\n",getppid(),getpid());
11 execl("./myexe","myexe",NULL);//将执行程序路径，执行的程序替换成自己的即可
12 exit(1);
13 }
14 int status = 0;
15 pid_t ret = waitpid(-1, &status, 0);
16 if(ret == id && WIFEXITED(status))
17 {
18 printf("child is over, signal: %d\n",WEXITSTATUS(status));
19 }
20 }
myexe.c：
1 #include<stdio.h>
2 int main()
3 {
4 for(int i = 0; i < 10; ++ i)
5 {
6 printf("myexe: %d\n", i);
7 }
8 return 0;
9 }
此时我们执行make，我们的可执行文件就出来了
在运行我们的osexe程序，我们发现自己写的程序myexe，也调用起来了，这就是用exec*函数调用自己的写法
总结
- 什么是程序替换：通过exec*， 让特定进程去加载磁盘中的其他程序，已达到运行的目的，并且期间不会创建新的进程
- 为什么要进行程序替换：
1. 子进程执行父进程的一部分代码
2. 子进程自身新的程序的需求 - 如何进行程序替换：写时拷贝原理-》进程地址空间问题-》磁盘加载程序到内存-》对可执行文件的理解（exe 文件，exec* 一系列函数）
- exec*函数一旦返回了，就说明进程替换出错了
- 命名理解：
l(list) : 表示参数采用列表
v(vector) : 参数用数组
p(path) : 有p自动搜索环境变量PATH
e(env) : 表示自己维护环境变量
- 事实上,只有execve是真正的系统调用,其它五个函数最终都调用 execve,所以execve在man手册 第2节,其它函数在man手册第3节
我们可以综合前面的知识，做一个简易的shell
不了解shell的可以先看这篇文章：shell脚本语言.
然后shell读取新的一行输入，建立一个新的进程，在这个进程中运行程序 并等待这个进程结束。
所以要写一个shell，需要循环以下过程:
- 获取命令行
- 解析命令行
- 建立一个子进程（fork）
- 替换子进程（execvp）
- 父进程等待子进程退出（wait）
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <unistd.h>
4 #include <string.h>
5 #include <fcntl.h>
6 #define NUM 128
7 #define SIZE 32
8 char command_line[NUM];//装输入的命令
9 char *command_parse[SIZE];//解析的命令
10 int main()
11 {
12 while(1)
13 {
14 //置0
15 memset(command_line, '\0', sizeof(command_line));
16 printf("[dy@mymini_shell]$ ");
17 fflush(stdout);//将缓冲区的内容刷新出来
18
19 if(fgets(command_line, NUM-1, stdin))
20 {
21 command_line[strlen(command_line)-1] = '\0';
22 //1、利用strtok函数提取命令
23 int index = 0;
24 command_parse[index] = strtok(command_line, " ");
25 while(command_parse[index] != NULL)
26 {
27 index++;
28 command_parse[index] = strtok(NULL, " ");
29 }
30 pid_t id = fork();
31 if(id == 0)
32 { //2、子进程利用execvp执行命令
33 execvp(command_parse[0], command_parse);
34 exit(1);
35 }
36 int status = 0;
E> 37 pid_t ret = waitpid(-1, &status, 0);//父进程等待子进程退出
38 if(ret == id && WIFEXITED(status))
39 {
40 printf("child is exit, signal code: %d\n", ret);
41 }
42 }
总结
简单来说，自己实现的这个shell，运用的知识有以下几点：
1、C语言的一系列函数，memset、fflush、strtok
2、进程创建
3、进程等待
以上就是进程管理的内容了，更新不易，记得三连