进程控制（Linux）

进程控制

进程创建

进程创建有两种方式：
1、命令行启动（程序、指令等）
2、通过程序自身，fork创建子进程

fork函数

它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程

#include<unistd.h>
pid_t fork(void);
返回值：自进程中返回0，父进程返回子进程id，出错返回-1

所有 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<stdio.h>#include<string.h>intmain(){int i =0;for(i =0; i <150;++i){printf("%d：%s\n", i ,strerror(i));//系统的错误码list}return0;}

进程退出的三种情况都应该是父进程应该关心的，需要知道子进程退出的结果，需要关心它的退出码。
实际子进程退出，父进程可以关心，也可以不关心子进程的运行结果。我们这里谈论的是父进程关心子进程的运行结果。

正常终止（可以通过 echo $? 查看进程退出码）：

1. 从main返回
2. 调用exit
3. _exit

异常退出：

ctrl + c，信号终止

1、从main返回

main函数的return 0 表示终止进程

非main函数的return不是终止进程，而是结束函数

#include<stdio.h>#include<string.h>intshow(){return1;//表示函数结束，不是终止进程}intmain(){show();}

2、调用exit

#include <unistd.h>
void exit(int status);
任何函数使用exit，都表示终止进程

3、_exit

#include <unistd.h>
void _exit(int status);
参数：status 定义了进程的终止状态，父进程通过wait来获取该值

第2、3种情况总结：

exit：在退出的时候，会进行后续资源处理，并且会刷新缓冲区
_exit：在退出的时候，不会进行后续资源处理，直接终止进程

exit做的其他工作：

1. 执行用户通过 atexit或on_exit定义的清理函数。
2. 关闭所有打开的流，所有的缓存数据均被写入
3. 调用_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<sys/types.h>
#include<sys/wait.h>
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>6intmain(void)7{8   pid_t pid =fork();
E>9if( pid ==-1)10perror("fork"),exit(1);11if( pid ==0){12int count =5;13while(count--)14{
E>15printf("child is running, ppid: %d pid: %d\n",getppid(),getpid());
E>16sleep(1);17}18exit(10);//终止子进程19}else{20printf("father is waiting!!!\n");21int st;22int ret =wait(&st);//先不关心退出的状态23if( ret >0&&(st &0x7F)==0){// 正常退出24printf("child exit code：%d\n",(st>>8)&0xFF);25}26elseif( ret >0){// 异常退出27printf("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>6intmain(void)7{8   pid_t pid;
E>9if((pid=fork())==-1)10perror("fork"),exit(1);11if( pid ==0){12int count =5;13while(count--)14{
E>15printf("child is running, ppid: %d pid: %d\n",getppid(),getpid());
E>16sleep(1);17}18exit(10);//终止子进程19}else{20printf("father is waiting!!!\n");21int st;22     pid_t ret =waitpid(pid,&st,0);23if(ret >=0){24printf("wait child success...\n");25if(WIFEXITED(st)){26printf("exit code: %d\n",WEXITSTATUS(st));27}28else{29printf("killed by siganl %d\n",WIFEXITED(st));30}31}                                                
E>32sleep(5);//5 seconds after exit33}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<stdio.h>2 #include <stdlib.h>3 #include <unistd.h>4 #include <sys/types.h>5 #include <sys/wait.h>6intmain()7{8   pid_t pids[10];9int i =0;10for(i =0; i <5; i++){11     pid_t id =fork();12if(id <0){13perror("fork error");14return1;15}16if(id ==0){17//child18int count =5;19while(count--)20{21printf("child is running, ppid：%d, pid：%d\n",getppid(),getpid());22sleep(1);23}24exit(i +1);25}26     pids[i]= id;2728}29for(i =0; i <5; i++){30int st =0;31     pid_t ret =waitpid(pids[i],&st,0);32if(ret >=0){33//wait child success34printf("wiat child success..PID:%d\n", pids[i]);35sleep(1);//睡上1秒在测试是否正常退出36if(WIFEXITED(st)){37//exit normal38printf("exit code:%d\n",WEXITSTATUS(st));39}40else{41//signal killed42printf("killed by signal %d\n",WIFEXITED(st));43}44}45}46return0;47}

三、基于非阻塞的轮流检查方案

• WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。

当子进程未退出时，父进程都在一直等待子进程退出，在等待期间，父进程不能做任何事情，这种等待叫做阻塞等待
我们可以不断去检查子进程的状态，当子进程未退出时，父进程可以做一些自己的事情，这种等待叫做非阻塞等待

1 #include <stdio.h>2 #include <unistd.h>3 #include <stdlib.h>4 #include <sys/wait.h>5intmain()6{7   pid_t pid =fork();8if(pid <0){9printf("%s fork error\n",__FUNCTION__);10return1;11}elseif( pid ==0){//child12printf("child is run, pid is : %d\n",getpid());13sleep(5);14exit(1);15}else{16int status =0;17     pid_t ret =0;18do19{20        ret =waitpid(-1,&status, WNOHANG);//非阻塞式等待21if( ret ==0){22printf("child is running\n");23}24sleep(1);25}while(ret ==0);26if(WIFEXITED(status)&& ret == pid ){27printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status));28}else{29printf("wait child failed, return.\n");30return1;31}32}33return0;34}

父进程每隔一段时间就会去检测子进程的情况，其他时间做自己的事，直到子进程退出，此时等待成功。

进程替换

替换原理

1、用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支)
2、子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。
3、调用exec并不创建新进程,所以调用exec前后该进程的id并未改变

子进程进行进程程序替换后，会影响父进程的代码和数据吗？

子进程刚被创建时，父子进程共享代码和数据，当子进程要对代码和数据进行写入时，此时发生写时拷贝，进行程序替换后，并不会影响服进行的代码和数据。

那怎么进行程序替换，此时就要用到系统的exec等一系列函数。

替换函数

其实有六种以exec开头的函数,统称exec函数:

#include<unistd.h>`intexecl(constchar*path,constchar*arg,...);intexeclp(constchar*file,constchar*arg,...);intexecle(constchar*path,constchar*arg,...,char*const envp[]);intexecv(constchar*path,char*const argv[]);intexecvp(constchar*file,char*const argv[])intexecve(constchar*path,char*const argv[],char*const envp[]);

1 #include <unistd.h>2 #include<stdio.h>3 #include<stdlib.h>4intmain()5{
W>6char*const argv[]={"ps","-ef",NULL};
W>7char*const envp[]={"PATH=/bin:/usr/bin","TERM=console",NULL};8execl("/bin/ps","ps","-ef",NULL);9// 带p的，可以使用环境变量PATH，无需写全路径10execlp("ps","ps","-ef",NULL);11// 带e的，需要自己组装环境变量12execle("ps","ps","-ef",NULL, envp);13execv("/bin/ps", argv);14// 带p的，可以使用环境变量PATH，无需写全路径15execvp("ps", argv);16// 带e的，需要自己组装环境变量17execve("/bin/ps", argv, envp);18exit(0);19return0;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>5intmain()6{7   pid_t id =fork();8if(id ==0)9{10printf("child fork success, getppid: %d, getpid: %d\n",getppid(),getpid());11execl("./myexe","myexe",NULL);//将执行程序路径，执行的程序替换成自己的即可12exit(1);13}14int status =0;15   pid_t ret =waitpid(-1,&status,0);16if(ret == id &&WIFEXITED(status))17{18printf("child is over, signal: %d\n",WEXITSTATUS(status));19}20}

myexe.c：

1 #include<stdio.h>2intmain()3{4for(int i =0; i <10;++ i)5{6printf("myexe: %d\n", i);7}8return0;9}

此时我们执行make，我们的可执行文件就出来了

在运行我们的osexe程序，我们发现自己写的程序myexe，也调用起来了，这就是用exec*函数调用自己的写法

总结

1. 什么是程序替换：通过exec*， 让特定进程去加载磁盘中的其他程序，已达到运行的目的，并且期间不会创建新的进程
2. 为什么要进行程序替换： 1. 子进程执行父进程的一部分代码 2. 子进程自身新的程序的需求
3. 如何进行程序替换：写时拷贝原理-》进程地址空间问题-》磁盘加载程序到内存-》对可执行文件的理解（exe 文件，exec* 一系列函数）
4. exec*函数一旦返回了，就说明进程替换出错了
5. 命名理解： l(list) : 表示参数采用列表 v(vector) : 参数用数组 p(path) : 有p自动搜索环境变量PATH e(env) : 表示自己维护环境变量
6. 事实上,只有execve是真正的系统调用,其它五个函数最终都调用 execve,所以execve在man手册 第2节,其它函数在man手册第3节

我们可以综合前面的知识，做一个简易的shell

不了解shell的可以先看这篇文章：shell脚本语言.


然后shell读取新的一行输入，建立一个新的进程，在这个进程中运行程序 并等待这个进程结束。
所以要写一个shell，需要循环以下过程:

1. 获取命令行
2. 解析命令行
3. 建立一个子进程（fork）
4. 替换子进程（execvp）
5. 父进程等待子进程退出（wait）

1 #include <stdio.h>2 #include <stdlib.h>3 #include <unistd.h>4 #include <string.h>5 #include <fcntl.h>6 #define NUM 1287 #define SIZE 328char command_line[NUM];//装输入的命令9char*command_parse[SIZE];//解析的命令10intmain()11{12while(1)13{14//置015memset(command_line,'\0',sizeof(command_line));16printf("[dy@mymini_shell]$ ");17fflush(stdout);//将缓冲区的内容刷新出来1819if(fgets(command_line, NUM-1,stdin))20{21       command_line[strlen(command_line)-1]='\0';22//1、利用strtok函数提取命令23int index =0;24       command_parse[index]=strtok(command_line," ");25while(command_parse[index]!=NULL)26{27         index++;28         command_parse[index]=strtok(NULL," ");29}30       pid_t id =fork();31if(id ==0)32{//2、子进程利用execvp执行命令33execvp(command_parse[0], command_parse);34exit(1);35}36int status =0;
E>37       pid_t ret =waitpid(-1,&status,0);//父进程等待子进程退出38if(ret == id &&WIFEXITED(status))39{40printf("child is exit, signal code: %d\n", ret);41}42}

总结

简单来说，自己实现的这个shell，运用的知识有以下几点：
1、C语言的一系列函数，memset、fflush、strtok
2、进程创建
3、进程等待

以上就是进程管理的内容了，更新不易，记得三连