【C++高并发服务器WebServer】-3：进程控制（退出进程、孤儿进程、僵尸进程、进程回收）

本文目录

总结：进程的用户区和内核区
一、进程退出
二、孤儿进程
三、僵尸进程
四、进程回收

总结：进程的用户区和内核区

现代操作系统中，每个进程都会被分配一个虚拟地址空间，这个虚拟地址空间通常被划分为用户区和内核区。这种划分方式在大多数现代操作系统（如 Linux、Windows、macOS 等）中都非常常见。

首先是虚拟地址空间：虚拟地址空间是操作系统为每个进程提供的一个逻辑地址空间。它通过内存管理单元（MMU）和分页机制将进程的逻辑地址映射到物理内存地址。虚拟地址空间的引入有以下好处：

隔离性：每个进程的虚拟地址空间是独立的，一个进程无法直接访问另一个进程的内存空间，从而提高了系统的安全性和稳定性。
抽象性：进程可以通过虚拟地址访问内存，而无需关心物理内存的具体布局。
可扩展性：即使物理内存不足，系统也可以通过交换空间（swap space）等方式扩展可用内存。

用户区（User Space）：用户区是进程可以直接访问的地址空间部分，主要用于存放进程的代码、数据、堆（heap）、栈（stack）等。用户区的特点包括：

可访问性：进程可以直接在用户区执行代码和访问数据。
隔离性：每个进程的用户区是独立的，进程无法访问其他进程的用户区。
大小：用户区的大小通常取决于系统的架构。例如，在 64 位系统中，用户区的大小可以非常大（接近 2^48 字节），而在 32 位系统中，用户区的大小通常为 2-3 GB。

内核区是操作系统内核专用的地址空间部分，用于存放内核代码、内核数据结构、驱动程序等。内核区的特点包括：

保护性：内核区是受保护的，普通进程无法直接访问内核区。只有在系统调用或中断处理时，进程才会切换到内核模式，从而可以访问内核区。
共享性：内核区是所有进程共享的，内核代码和数据结构对所有进程都是可见的（但仍然受到保护）。

进程在运行过程中会在用户模式（User Mode）和内核模式（Kernel Mode）之间切换：

用户模式：进程在用户区运行，执行用户代码，访问用户区的内存。用户模式下，进程无法直接访问内核区，也无法执行特权指令。
内核模式：当进程发起系统调用（如 I/O 操作、内存分配等）或发生中断时，进程会切换到内核模式。在内核模式下，进程可以访问内核区，执行特权指令，并由内核代为完成操作。

内核有很多重要的东西，我们来看看一些比较重要的。

进程控制块（PCB）是内核管理进程的核心数据结构，它保存了进程的所有状态信息，包括：

进程状态：运行态、就绪态、阻塞态等。
进程标识符：进程ID（PID）和父进程ID。
程序计数器（PC）：指向进程下一条指令的地址。
寄存器状态：保存进程切换时的寄存器值。
内存管理信息：如页表指针、内存映射信息等。
I/O状态信息：如打开的文件描述符、I/O请求队列等。
优先级和调度信息：用于进程调度的优先级、时间片等。
信号处理信息：进程接收到的信号及其处理方式。

内核区还包含操作系统内核的代码和数据，这些内容对所有进程共享，但受到保护，只能在内核模式下访问。主要包括：

内核代码：操作系统的核心功能代码，如进程调度、内存管理、文件系统管理、设备驱动等。
全局数据结构：如进程表（存储所有进程的 PCB）、文件表（管理打开的文件）、设备表（管理设备驱动）等。

内核区还包含动态加载的内核模块和设备驱动程序。这些模块和驱动程序扩展了内核的功能，例如：

设备驱动：管理硬件设备（如磁盘、网卡、显卡等）。
内核扩展模块：如文件系统模块（如 ext4、NTFS）、网络协议模块（如 TCP/IP）等。

内核区还包含用于内存管理的数据结构，如：

页表：用于虚拟内存到物理内存的映射。
空闲内存管理数据结构：如 Buddy 系统或 SLAB 分配器，用于管理空闲内存块。
内存映射区域（VMA）：描述进程的虚拟内存区域，包括用户区的代码段、数据段、堆、栈等。

内核区还包含其他一些重要的资源，例如：

中断处理程序和中断向量表：用于处理硬件中断。
同步原语：如互斥锁、信号量、自旋锁等，用于内核线程之间的同步。
内核线程的上下文信息：内核线程的运行状态和调度信息。

内核区还包含文件系统相关的数据结构，如：

超级块（Superblock）：描述文件系统的元数据。
inode 表：存储文件和目录的元信息。
目录项（dentry）缓存：用于加速文件路径查找。

一、进程退出

cpp 复制代码

//标准C库代码
#include <stdlib.h>
void exit(int status);

//Linux库代码
#include <unistd.h>
void _exit(int status);

cpp 复制代码

/*
    #include <stdlib.h>
    void exit(int status);

    #include <unistd.h>
    void _exit(int status);

    status参数：是进程退出时的一个状态信息。父进程回收子进程资源的时候可以获取到。
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {

    printf("hello\n");
    printf("world");

    // exit(0);
    _exit(0);
    
    return 0;
}

如果执行exit(0)，那么就会输出 hello world。但是执行_exit(0）就只会输出hello。

exit() 是一个标准库函数，定义在 <stdlib.h> 中。它的作用是终止程序的运行，但在终止之前，它会执行以下操作：

刷新标准输出缓冲区：exit() 会调用 fflush(stdout)，确保所有未输出的内容都被写到终端。
关闭文件流：关闭所有打开的文件流。
执行清理操作：调用之前通过 atexit() 注册的清理函数。
终止程序：调用 _exit() 或 _Exit() 来终止程序。

因此，如果使用 exit(0)，程序会先刷新缓冲区，将 "world" 输出到终端，然后终止程序。

对于_exit，因为hello后面跟了\n这个换行符，换行符是自带刷新缓冲区的。也就是C语言的标准输出（stdout）是行缓冲的。这意味着只有在遇到换行符（\n）或者缓冲区满时，才会将内容输出到终端。但是world没有\n，会被放到缓冲区里面，而_exit(0)是不会刷新缓冲区。所以不会执行world输出。

如果打算在程序终止时输出 "world"，可以在 _exit(0) 之前手动刷新缓冲区：

cpp 复制代码

fflush(stdout);
_exit(0);

二、孤儿进程

父进程运行结束，但子进程还在运行(未运行结束)，这样的子进程就称为孤儿进程(Orphan Process)。

每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为init，而init进程会循环地 wait()它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init进程就会代表党和政府出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。

cpp 复制代码

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>

int main() {

    // 创建子进程
    pid_t pid = fork();

    // 判断是父进程还是子进程
    if(pid > 0) {

        printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());

    } else if(pid == 0) {
        sleep(2);
        // 当前是子进程
        printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid());
       
    }

    // for循环
    // for(int i = 0; i < 3; i++) {
    //     printf("i : %d , pid : %d\n", i , getpid());
    // }

    return 0;
}

运行后可以看到下面的输出：

由于让子进程sleep了两秒，所以输出的ppid是1，被内核分配到进程号为1的进程，然后让进程1来回收这个子进程的所有资源。

还有个点就是，当父进程死亡之后，终端就会切换到前台（也就是我们会看到终端插入了一行输出）。也就是运行./orphan的时候，终端作为这个程序的父进程，会知道这个父进程什么时候死亡，所以当父进程运行完毕之后，就知道切换到前台，但是终端前台不知道还有个子进程，所以子进程继续输出了。子进程之所以会继续输出，是因为拷贝的虚拟地址内存中的内核区的文件描述符是一样的（前三个文件描述符是012，也就是输入、输出、错误），所以子进程知道在哪个终端前台继续输出。

三、僵尸进程

每个进程结束之后, 都会释放自己地址空间中的用户区数据（比如说栈、堆这些），内核区的 PCB 没有办法自己释放掉，需要父进程去释放。

进程终止时，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸（Zombie）进程。

僵尸进程不能被 kill -9 杀死。

这样就会导致一个问题，如果父进程不调用 wait() 或 waitpid() 的话，那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵尸进程，将因为没有可用的进程号而导致系统不能产生新的进程，此即为僵尸进程的危害，应当避免。

cpp 复制代码

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>

int main() {

    // 创建子进程
    pid_t pid = fork();

    // 判断是父进程还是子进程
    if(pid > 0) {
        while(1) {
            printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());
            sleep(1);
        }

    } else if(pid == 0) {
        // 当前是子进程
        printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid());
       
    }

    // for循环
    for(int i = 0; i < 3; i++) {
        printf("i : %d , pid : %d\n", i , getpid());
    }

    return 0;
}

运行上面的代码，会发现父进程一直在while循环中，回收不了子进程的内核区的资源（pcb这些），但是子进程已经死亡结束了，通过ps aux查看对应的进程情况。

在下面可以看到[zombie]代表僵尸进程，未定义的。状态的z+也表示是zombie僵尸进程。

就算输入 kill -9 14860这个僵尸进程还是会在，是杀不死的。所以我们把父进程给终止，僵尸进程就会不存在了。

四、进程回收

在每个进程退出的时候，内核释放该进程所有的资源、包括打开的文件、占用的内存等。但是仍然为其保留一定的信息，这些信息主要主要指进程控制块PCB的信息(包括进程号、退出状态、运行时间等)。

父进程可以通过调用wait或waitpid得到它的退出状态同时彻底清除掉这个进程。

wait()和 waitpid()函数的功能一样，区别在于，wait()函数会阻塞（也就是等待子进程结束），waitpid()可以设置不阻塞（但是默认也是阻塞的），waitpid()还可以指定等待哪个子进程结束。

一次wait或waitpid调用只能清理一个子进程，清理多个子进程应使用循环。

通过命令man 2 wait来查看对应的man文档中的wait说明：

cpp 复制代码

WIFEXITED(status) 非0，进程正常退出
WEXITSTATUS(status) 如果上宏为真，获取进程退出的状态（exit的参数）

WIFSIGNALED(status) 非0，进程异常终止
WTERMSIG(status) 如果上宏为真，获取使进程终止的信号编号

WIFSTOPPED(status) 非0，进程处于暂停状态
WSTOPSIG(status) 如果上宏为真，获取使进程暂停的信号的编号
WIFCONTINUED(status) 非0，进程暂停后已经继续运行

cpp 复制代码

/*
    #include <sys/types.h>
    #include <sys/wait.h>
    pid_t wait(int *wstatus);
        功能：等待任意一个子进程结束，如果任意一个子进程结束了，此函数会回收子进程的资源。
        参数：int *wstatus
            进程退出时的状态信息，传入的是一个int类型的地址，但是我们需要这个地址中的int数据值去做判断，所以是传出参数。
        返回值：
            - 成功：返回被回收的子进程的id
            - 失败：-1 (所有的子进程都结束，调用函数失败)

    调用wait函数的进程会被挂起（阻塞），直到它的一个子进程退出或者收到一个不能被忽略的信号时才被唤醒（相当于继续往下执行）
    如果没有子进程了，函数立刻返回，返回-1；如果子进程都已经结束了，也会立即返回，返回-1.

*/
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>


int main() {

    // 有一个父进程，创建5个子进程（兄弟）
    pid_t pid;

    // 创建5个子进程
    for(int i = 0; i < 5; i++) {
        pid = fork();
        if(pid == 0) {
            break;
            //为了防止子进程继续产生子进程。
            //不然子进程从这个循环会一直产生下去。
        }
    }

    if(pid > 0) {
        // 父进程
        while(1) {
            printf("parent父进程, pid = %d\n", getpid());
            // int ret = wait(NULL); 表示不想获取子进程的状态
            int st;
            int ret = wait(&st);
            if(ret == -1) {
                break;
            }
            if(WIFEXITED(st)) {
                // 是不是正常退出
                printf("退出的状态码：%d\n", WEXITSTATUS(st));
            }
            if(WIFSIGNALED(st)) {
                // 是不是异常终止
                printf("被哪个信号干掉了：%d\n", WTERMSIG(st));
            }
            printf("child die, pid = %d\n", ret);
            sleep(1);
        }

    } else if (pid == 0){
        // 子进程
         //while(1) {
            printf("child子进程, pid = %d\n",getpid());    
            sleep(1);       
         //}

        exit(0);
    }

    return 0; // 等价于exit(0)
}

编译上面的代码运行，我们看看运行的结果：退出的状态码为0是因为我们在子进程的代码中定义了exit(0)，也就是自己定义的是0，如果定义的是1，那么输出的"退出的状态码：1"。

如果把子进程代码的while代码加上之后，通过另一个终端界面输入Kill -9杀掉对应的子进程，那么输出的状态就是：

接下来我们看看waitpid()函数作用：

cpp 复制代码

/*
    #include <sys/types.h>
    #include <sys/wait.h>
    pid_t waitpid(pid_t pid, int *wstatus, int options);
        功能：回收指定进程号的子进程，可以设置是否阻塞。
        参数：
            - pid:
                pid > 0 : 某个子进程的pid
                pid = 0 : 回收当前进程组的所有子进程    
                pid = -1 : 回收所有的子进程，相当于 wait()  （最常用）
                pid < -1 : 某个进程组的组id的绝对值，回收指定进程组中的子进程
            - options：设置阻塞或者非阻塞
                0 : 阻塞
                WNOHANG : 非阻塞
            - 返回值：
                > 0 : 返回子进程的id
                = 0 : options=WNOHANG, 表示还有子进程或者
                = -1 ：错误，或者没有子进程了
*/
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main() {

    // 有一个父进程，创建5个子进程（兄弟）
    pid_t pid;

    // 创建5个子进程
    for(int i = 0; i < 5; i++) {
        pid = fork();
        if(pid == 0) {
            break;
        }
    }

    if(pid > 0) {
        // 父进程
        while(1) {
            printf("parent, pid = %d\n", getpid());
            sleep(1);

            int st;
            // int ret = waitpid(-1, &st, 0);
            int ret = waitpid(-1, &st, WNOHANG);

            if(ret == -1) {
                break;
            } else if(ret == 0) {
                // 说明还有子进程存在
                continue;
            } else if(ret > 0) {

                if(WIFEXITED(st)) {
                    // 是不是正常退出
                    printf("退出的状态码：%d\n", WEXITSTATUS(st));
                }
                if(WIFSIGNALED(st)) {
                    // 是不是异常终止
                    printf("被哪个信号干掉了：%d\n", WTERMSIG(st));
                }

                printf("child die, pid = %d\n", ret);
            }
           
        }

    } else if (pid == 0){
        // 子进程
         while(1) {
            printf("child, pid = %d\n",getpid());    
            sleep(1);       
         }
        exit(0);
    }

    return 0; 
}