Linux : 进程等待以及进程终止

进程控制之进程等待

（一）fork函数
- 1*fork函数返回值
- 2.父子进程的写时拷贝
（二）进程终止
- 1.进程退出码
- 2.进程常见退出方法
- - （1）_exit
  - （2）exit
  - （3）return
- 3.进程的异常退出
（三）进程等待
- 1.获得子进程status
- 2.进程等待的方法
- - （1）wait方法
  - （2）waitpid方法
- 3.多进程创建和等待
- 4.非阻塞接口的轮询检测

（一）fork函数

在linux中fork函数时非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。

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

进程调用fork，当控制转移到内核中的fork代码后，内核做：

分配新的内存块和内核数据结构给子进程
将父进程部分数据结构内容拷贝至子进程
添加子进程到系统进程列表当中
fork返回，开始调度器调度
fork之后，父子进程谁先执行完全由调度器决定。

1*fork函数返回值

子进程返回0。
父进程返回的是子进程的pid。

子进程只有一个父进程的，而父进程可以有很多个子进程。对于子进程来讲，它的父进程是根本不需要被标识，因为天然就知道它的父进程；而对于父进程来讲，它的子进程是需要被标识的，因为父进程的子进程是可以有很多的，所以就需要进行标识哪一个子进程。父进程只有知道子进程的标识符的时候，才能更好的给子进程分配任务。

调用fork函数后，操作系统都做了什么？？
父进程调用fork函数后，为了创建子进程，fork函数内部将会进行一系列操作，包括创建子进程的进程控制块（PCB）、创建子进程的进程地址空间(mm_struct)、创建子进程对应的页表等等。子进程创建完毕后，操作系统还需要将子进程的进程控制块添加到系统进程列表当中，此时子进程便创建完毕了。

因此在fork函数返回前，子进程已经创建完毕，所以父子进程都执行了return语句，这也是为什么fork函数有两个返回值的原因。

2.父子进程的写时拷贝

通常，父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。
可以这么理解：
子进程把父进程的进程地址空间和页表以及代码数据都拷贝到了自己身上。当父子进程某一方对代码数据进行写入进行写时拷贝

操作系统如何实现写时拷贝操作？
下面是一个父进程的模拟图。

看到上面这个图，原本父进程的某个代码数据是可读写状态的，当创造子进程的时候，这个状态就会变成只读状态，
如下图：
在这里插入图片描述

那么原本可读写的数据变成了可读，如何进行对该数据写入呢？
当父子进程的某一方要对原本可读写的数据进行写入时，操作系统就会识别出原本该数据位置时可以写入的，操作系统并不会做出异常处理，而是把数据拷贝一份下来，并在物理内存中开辟一个空间，将修改后的数据写进去。然后对写入数据的进程的对应页表处进行重新映射。

比如子进程修改数据时：
进行写时拷贝之后，操作系统会对原本可读写的状态进行恢复，如下图
在这里插入图片描述

为什么不在创建子进程的时候就进行数据的拷贝,而是通过页表指向同一块物理地址呢？
子进程不一定会使用父进程的所有数据，并且在子进程不对数据进行写入的情况下，没有必要对数据进行拷贝，操作系统会按需分配，在需要修改数据的时候再分配，这样可以高效的使用内存空间。
写时拷贝的意义
进程具有独立性。多进程运行，需要独享各种资源，多进程运行期间互不干扰，不能让子进程的修改影响到父进程。
代码会不会进行写时拷贝？
90%的情况下是不会的，但这并不代表代码不能进行写时拷贝，例如在进行进程替换的时候，则需要进行代码的写时拷贝。

fork的常规用法

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

fork调用失败的原因

系统中有太多的进程
实际用户的进程数超过了限制

（二）进程终止

进程退出场景有三种：

代码运行完毕，结果正确
代码运行完毕，结果不正确
代码异常终止

1.进程退出码

在main函数结尾，我们最后都会写上 return 0；这个0便是退出码。那么我们为什么要写退出码呢？？其实main函数也是被调度的函数，操作系统也需要知道main函数是否正确执行完毕，而规定0表示代码成功执行完毕，以非0表示代码执行过程中出现错误，所以我们结尾都写 return 0；

查看最近一次进程的退出码信息：

echo $? //查看最近一次进程的退出码信息

在这里插入图片描述

查看进程的退出码对应描述：
使用strerror命令。
通过如下代码我们可以查看对应退出码信息

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

int main()
{
    for (int i = 0; i < 200; i++)
    {
        printf("退出码%d: %s\n", i, strerror(i));
    }
    return 0;
}

在这里插入图片描述

退出码都有对应的字符串含义，帮助用户确认执行失败的原因，而这些退出码具体代表什么含义是人为规定的，不同环境下相同的退出码的字符串含义可能不同。

2.进程常见退出方法

从main返回
调用exit
_exit

异常退出：

ctrl + c，信号终止

（1）_exit

_exit函数也可以在代码中的任何地方退出进程，但是_exit函数会直接终止进程，并不会在退出进程前做任何收尾工作。

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

int main()
{
    printf("Hello World"); //注意这里没加\n
    sleep(1);
    _exit(1);
}

运行结果如下：
在这里插入图片描述
可以看到这里并没有执行打印，因为_exit函数并不会刷新缓冲区，只是一味的退出进程。

（2）exit

exit最后也会调用_exit, 但在调用exit之前，还做了其他工作：

执行用户通过 atexit或on_exit定义的清理函数。
关闭所有打开的流，所有的缓存数据均被写入
调用_exit

（3）return

return是一种更常见的退出进程方法。执行return n等同于执行exit(n),因为调用main的运行时函数会将main的返回值当做 exit的参数。

3.进程的异常退出

进程发生异常时，进程会直接终止。进程出现异常，本质是我们的进程收到了对应的信号。
通常代码错误导致进程运行时异常退出。

任何进程最终的执行情况有两个数字表示：

退出信号
进程退出码

而进程信号出现异常，进程会直接退出并且弹出对应的错误信息，例如下面这样
在这里插入图片描述

我们可以通过如下命令查看对应的进程信号
在这里插入图片描述
这里没有0，因为0是正常的，没有异常。

（三）进程等待

进程等待必要性

子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。
另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力，因为谁也没有办法杀死一个已经死去的进程。
最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。
父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息

1.获得子进程status

wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。
如果传递NULL，表示不关心子进程的退出状态信息。
否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
status不能简单的当作整形来看待，可以当作位图来看待

具体细节如下图（只研究status低16比特位）：
在这里插入图片描述
进程正常退出的时候，高8位表示进程的退出状态，即退出码。
进程若是被信号所杀，则低7位表示终止信号，而第8位比特位是core dump标志。

如何从status得到进程的退出码和退出信号
exitCode = (status >> 8) & 0xFF; //退出码
exitSignal = status & 0x7F; //退出信号

系统当中提供了两个宏来获取退出码和退出信号。
WIFEXITED(status)：用于查看进程是否是正常退出，本质是检查是否收到信号。
WEXITSTATUS(status)：用于获取进程的退出码。

2.进程等待的方法

（1）wait方法

等待任意子进程,默认是阻塞等待

原型：pid_t wait(int* status);
等待成功返回被等待进程的pid，等待失败返回-1。
参数：输出型参数，获取子进程的退出状态，不关心可设置为NULL。

我们通过如下代码进行测试：

int main()
{
    pid_t id = fork();

    if(id == 0)
    {
        int cnt = 3;
        while(cnt--)
        {
            printf("我是子进程，pid: %d, ppid: %d\n",getpid(),getppid());
            sleep(1);
        }
        exit(0);
    }
    //父进程
    int status = 0;
    pid_t ret = wait(&status);
    if(ret == id)
    {
        printf("wait success\n");

        printf("exit code : exit signal: %d , exit ret: %d\n",WIFEXITED(status),WEXITSTATUS(status));
    }
    
    sleep(3);
    return 0;
}

运行结果如下：
在这里插入图片描述

（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: (与wait函数的用法相同)
WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）
WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）
options:
WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。
等于0：父进程会一直等待子进程。

我们通过下面代码认识一下waitpid：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{
    pid_t id = fork();

    if(id == 0)
    {
        int cnt = 3;
        while(cnt--)
        {
            printf("我是子进程，pid: %d, ppid: %d\n",getpid(),getppid());
            sleep(1);
        }
        exit(1);
    }
    //父进程
    int status = 0;
    pid_t ret = waitpid(id,&status,0);
    if(ret == id)
    {
        printf("wait success\n");

        printf("exit code : exit signal: %d , exit ret: %d\n",WIFEXITED(status),WEXITSTATUS(status));
    }
    
    sleep(3);
    return 0;
}

运行结果：
在这里插入图片描述

如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退出信息。
如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞。
如果不存在该子进程，则立即出错返回。

3.多进程创建和等待

通过循环创建多个进程，但是要注意子进程的相关代码完成记得退出，否则子进程会执行原本父进程该执行的语句，造成混乱

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{

    for (int i = 0; i < 10; i++)
    {
        pid_t id = fork();
        if (id == 0)
        {
            // child
            printf("我是子进程：%d\n", i);
            sleep(1);
            exit(i);
        }
    }
    for (int i = 0; i < 10; i++)
    {
        int status = 0;
        pid_t ret = waitpid(-1, &status, 0);
        if (ret >= 0)
        {
            // wait 
            printf("等待成功\n");
            if (WIFEXITED(status))
            {

                printf("exit code:%d\n", WEXITSTATUS(status));
            }
            else
            {
                // 信号出错
                printf("信号出错，信号为：%d\n", status & 0x7F);
            }
        }
        else
        {
            printf("wait fail\n");
        }
    }
    return 0;
}

运行结果如下：
在这里插入图片描述

4.非阻塞接口的轮询检测

waitpid的第三个option参数为0时，是阻塞等待，即父进程会一直等待子进程的推出信息才会运行后面的代码。这种情况下，如果子进程的运行时间还很久，而父进程却一直等待，会造成内存空间的浪费，即内存泄漏。

当option = WNOHANG时，父进程在等待子进程退出的时候会继续运行代码，也就是子进程未退出的时候父进程去干别的事情，子进程退出的时候，父进程在通过wait或者是waitpid去接收再双双退出。

我们可以通过循环调用的waitpid的方式实现非阻塞接口的轮询，代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
    pid_t id = fork();
    if (id == 0)
    {
        // child
        int count = 3;
        while (count--)
        {
            printf("子进程..., getppid():%d\n", count, getpid(), getppid());
            sleep(3);
        }
        exit(0);
    }
    // father
    while (1)
    {
        int status = 0;
        pid_t ret = waitpid(id, &status, WNOHANG);
        if (ret > 0)
        {
            // wait sucess
            printf("等待成功\n");
            printf("exit code:%d\n", WEXITSTATUS(status));
            break;
        }
        else if (ret == 0) // 等于0时
        {
            // 子进程没结束
            printf("父进程可以做某些工作\n");
            sleep(1);
        }
        else
        {
            // wait fail
            printf("wait fail\n");
            break;
        }
    }
    return 0;
}