Linux 进程控制相关函数_void exit(int status)

printf("Hello WhiteShirtI\n");
return 0;

}

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210311124714238.png)  
 并没有打印任何东西  
 库函数和系统调用接口的关系：库函数封装了系统调用接口，原因是系统调用接口对用户不太友好。  
 这三种终止进程的方式有什么不同呢？


1. `return`是等到进程退出的时候会刷新缓冲区，如果`return`在main函数中退出，整个进程才会退出  
 main.c

//main.c
int main()
{
printf(“hello WhiteShirtI”);
sleep(5);;
return 0;
}

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210311125806842.png)  
 虽然printf()函数在sleep的前面，但是打印并没有换行。也就是没有手动刷新缓冲区，所以直到运行5秒后，return进程结束才会刷新缓冲区，打印hello WhiteShirtI。


2. `exit()`函数和return一样，进程退出后会刷新缓冲区，但是`exit()`是可以在任意位置调用，一旦调用就会退出调用的进程
3. `_exit()`系统调用接口是当进程退出的时候直接释放资源，并不会刷新缓冲区
4. 以上三种进程退出方式都属于正常进程退出，会根据返回值向父进程表示退出原因


**异常退出**：程序崩溃，由于某种错误导致程序没运行完就突然退出


## 进程等待


**进程等待**就是父进程等待子进程的退出，获取子进程的返回值，从而避免产生僵尸进程


#### `pid_t wait(int *status)`


`wait()`函数是阻塞等待任意一个字进程退出，获取子进程的返回值到status指向的空间中，并释放子进程资源，返回退出的子进程的pid  
 **阻塞**：为了完成某个功能发起一个调用，若当前不具备完成功能的条件，则调用后不返回，一直等待  
 **非阻塞**：为了完成某个功能发起一个调用，若当前不具备完成功能的条件，则立即报错返回，通常需要循环等待  
 wait()是阻塞等待  
 zombie.c

//zombie.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
pid_t pid = fork();
if (pid == 0)
{
sleep(5);
exit(0);
}
wait(NULL);
while(1)
{
sleep(1);
printf(“WhiteShirtI\n”);
}
return 0;
}

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210311140912315.png)  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210311140950221.png)


进程进行了进程等待，并没有产生僵尸进程


#### `pid_t waitpid(pid_t pid, int *status, int options)`


`waitpid()`函数的参数**pid**的作用


* 若 == -1，则表示等待任意一个子进程退出
* 若 > 0, 则表示等待指定的子进程退出


**status**：输出型参数，传入一个int空间的首地址，获取退出的子进程的返回值  
 **options**：选项参数


* 若 == 0,则表示默认阻塞等待；
* WNOHANG,将waitpid设置为非阻塞，没有子进程已经退出的话就立即报错返回


**返回值**：若等待到了子进程退出则返回子进程的pid；若有子进程但是没有退出，非阻塞，则返回0；出错返回-1；


wait() 和waitpid() 的关系：`wait(status) == waitpid(-1,status,0)`

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
pid_t pid = fork();
if (pid == 0)
{
sleep(5);
exit(0);
}
int res;
while((res = waitpid(pid, NULL, WNOHANG)) == 0)
{
printf(“没有子进程退出,等一下来看\n”);
}
while(1)
{
sleep(1);
printf(“WhiteShirtI\n”);
}
return 0;
}

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210311141759838.png)  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210311141903596.png)  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210311141914658.png)


循环进程等待，如果没有子进程退出，就去执行其他任务，当有子进程退出，就可以释放子进程的资源了，就不会产生僵尸进程。


非阻塞操作相对于阻塞操作的优点：对cpu利用更加充分，不用一直等待，但是必须循环进行等待  
 wait和waitpid并不是只处理刚退出的进程，而是对已经退出的进程进行处理(不管什么时候退出)


看看中间**status**参数的作用

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
pid_t pid = fork();
if (pid == 0)
{
sleep(5);
exit(255);
}
int res;
int status;
while((res = waitpid(pid, &status, WNOHANG)) == 0)
{
sleep(1);
printf(“没有子进程退出,等一下来看\n”);
}
printf(“status : %d\n”,status);
while(1)
{
sleep(1);
printf(“WhiteShirtI\n”);
}
return 0;
}

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210311143117527.png)  
 将exit(0)改为exit(255)后，为什么status会是65280呢？  
 65280转化成16进制就是`0xFF00`。  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210311143405578.png)


再改为exit(66)后，status为16896，转化为16进制是`0x4200`，再改为exit(256)后，status为0，转化为16进制就是`0x0000`。我们可以发现status只用了低16位中的高8位来存储地址  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210311143734476.png)  
 子进程的退出返回值，实际只有一个字节来存储空间，也就意味着返回值最好不要大于255  
 将address = status >> 8，右移8位后，再&0xff，只要低8位  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210311144051253.png)

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
pid_t pid = fork();
if (pid == 0)
{
sleep(5);
exit(66);
}
int res;
int status;
while((res = waitpid(pid, &status, WNOHANG)) == 0)
{
sleep(1);
printf(“没有子进程退出,等一下来看\n”);
}
printf(“status : %d\n”,(status >> 8) & 0xff);
while(1)
{
sleep(1);
printf(“WhiteShirtI\n”);
}
return 0;
}

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210311144447765.png)  
 但是我们知道进程退出有正常退出还有异常退出，如果子进程是异常退出，那么获取它的返回值就毫无意义，所以获取一个进程的返回值的前提是这个进程是正常退出的  
 那我们如何判断子进程是否是正常退出呢？  
 我们都知道，在status变量中低16位中的高8位是存放了进程退出的返回值，那低8位有什么作用呢，在低8位中的高一位是`core dump标志`，core dump标志是核心传储，就是程序异常退出时，会保存程序的运行信息，便于事后调试。可以通过`ulimit -a`查看是否core dump标志是否打开；默认是关闭的，原因是core file文件非常大，占空间，还存在一定的安全隐患  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210320154746579.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NDQzOTg2,size_16,color_FFFFFF,t_70)


而在低7位中，是用来保存了`程序异常退出的信号值`，那什么是信号呢？信号就是通知进程发生了某个异常事件，中断当前进程操作，去处理异常事件。在我们生活中也有很多信号，下课铃声和上课铃声，闹钟等。都在提醒我们应该去处理哪些事件。而在操作系统中的信号的体现实际是一个数字，数字就代表了某个异常事件，程序因为异常退出后，会将异常退出事件信号保存到低7位中  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/2021031212570581.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NDQzOTg2,size_16,color_FFFFFF,t_70)  
 通过以上知识总结：**如果status低7位全为0，则表示程序正常退出，否则表示程序异常退出**  
 所以我们可以用`status & ox7f`是否等于0来判断程序是否正常退出，正常退出就打印返回值，异常退出就不用打印返回值了。  
 但是操作系统为我们提供了两个接口，专门处理status的


* `WIFEXITED(status)`–用于根据status判断子进程是否正常退出 ==>`status & 0x7f == 0`
* `WEXITSTATUS(status)`–从status中取出子进程退出返回值==> `(status>>8)&0xff`  
 zombie.c  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210312131924348.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NDQzOTg2,size_16,color_FFFFFF,t_70)  
 运行上述代码，进程属于正常退出，会打印两次status的返回值  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210312132019982.png)


## 程序替换


我们都知道，创建子进程的目的有两个，第一个是与父进程做相同的事，分摊压力；另一个是让子进程做一些有危险的事，即使异常也不会影响主进程。那么想让子进程做其他的事，可以通过fork()函数的返回值不同进行分流。  
 但是这种方式存在缺陷，1、程序耦合度非常高，功能代码都是在一个程序中编写的，想要改变子进程的功能处理流程，就需要修改整个程序的代码，让整个程序重新进行运行编译；2、程序体积非常大


解决这个问题的最好办法就是**程序替换**  
 程序替换就是替换一个进程正在调度的程序信息(pcb)，将另一个程序加载到内存中，让原有的pcb不再调度原程序，而去调度这个新的程序。  
 在父子进程中，子进程几乎复制了父进程所有信息。下面是进程替换前后变化图  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/2021031214194820.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NDQzOTg2,size_16,color_FFFFFF,t_70)  
 程序替换本质就是替换pcb在内存中对应的代码和数据(将新的程序加载到内存中，更新页表信息,重新初始化虚拟地址)，让进程pcb重新开始调度新的程序运行


理解了程序替换，那我们如何在diam中实现程序替换呢？  
 `exec函数族`–实现进程的程序替换


* int execl(const char \*path, const char \*arg, …);
* int execlp(const char \*file, const char \*arg, …);
* int execle(const char \*path, const char \*arg, …, char \*const envp[]);
* int execv(const char \*path, char const argv[]);
* int execvp(const char *file, char*const argv[]);
* int execve(const char \*path, char \*const argv[], char \*const envp[]); 系统调用接口