【Linux】进程详解：进程的创建&终止&等待&替换

✨ 当时只道是寻常** ** 🌏

📃个人主页：island1314

🔥个人专栏：Linux—登神长阶

⛺️ 欢迎关注：👍点赞 👂🏽留言 😍收藏 💞 💞 💞

1. 前言🚀 ****

🌈之前在这两篇文章中

【Linux】进程管理：状态与优先级调度的深度分析

【Linux】进程详解：命令行参数、环境变量及地址空间-CSDN博客

我们已经了解过了进程的基本概念，这一章我们要进一步的学习进程，即 「进程的创建和终止」。

2. 进程创建🖊

2.1 fork()函数的深入了解

之前博客里面我们讲过了，现在只是来做个温习

创建进程有两种创建方式：

1. 使用 ****./ ****运行某一个可执行程序，这种是最常见的方式
2. 使用系统调用接口创建进程，即使用****fork()，fork()*函数可以帮助我们从原来的进程中创建一个新的子进程，而原来的进程就被叫做父进程*。

2.1.1 利用fork()创建进程

#include <unistd.h>
pid_t fork(); // 返回值有两个：子进程返回0，父进程返回子进程的PID，如果子进程创建失败返回-1

2.1.2 fork()在内核中做了啥？

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

• 分配新的内存块 和task_struct、mm_struct等内核数据结构给子进程
• 将父进程部分数据结构内容拷贝至子进程
• 添加子进程到系统进程列表当中
• **fork() **返回相应的返回值，开始调度器调度

• 当一个进程调用fork之后，就有两个二进制代码相同的进程。而且它们都运行到相同的地方。但每个进程都将可以开始它们自己的旅程

因此我们就可以知道fork()创建一个进程之所以会有两个返回值的原因

• 在**fork()**函数内部的执行的过程中，就已经创建了一个新的进程，所以新的进程会有一个返回值，而父进程也会有一个返回值

2.2.3 父子进程的关系

** 新创建的子进程机会和父进程一模一样，但是还是不完全一样**

• 子进程得到与父进程在用户级别虚拟地址空间相同的一份拷贝，包括代码和数据段，堆，共享库以及用户栈。而他们之间最大的区别就在于两个进程的PID不同
• 父进程和子进程是并发执行的独立进程
• 父进程和子进程有相同但是独立的地址空间，后面会讲到其实父进程和子进程在虚拟地址层面上地址空间是一样的，但是它们都有自己独立的物理地址空间
• 子进程继承了父进程中所有的打开文件，所以父子进程共享所有的文件

2.2 fork 函数返回值

在之前的博客中就说过了****fork()****函数有两个返回值，子进程返回0，父进程返回子进程的PID，下面就需要解决三个问题。

1. *fork()为什么会出现两个返回值❓ 1. 根据*fork()函数在内核中的操作就包含了子进程的数据结构的创建，所以在fork()返回之前，子进程就已经被创建出来了。而一旦被创建出来一个独立的进程就会有返回值，所以调用这个fork()函数的父进程有一个返回值，而创建出的子进程也会有一个返回值2. 因为这两个过程是在fork()函数内部就已经完成了，因此我们在fork()****函数外面看到的现象就是一个函数出现了两个返回值
2. .为什么子进程要返回0，而父进程要返回子进程的PID❓1. 一个父进程可以创建很多的子进程，而每一个子进程都只能有一个父进程2. 而父进程创建子进程是为了让子进程完成任务的，所以父进程需要标志每一个子进程，所以父进程通过返回子进程的PID来标识每一个子进程3. 而子进程只有唯一的父进程，所以不需要标识父进程，因此返回一个 0 就可以了

2.3 写时拷贝

通常，父子代码共享，父子不写入时，数据共享，当任意一方试图写入，便以写时拷贝的方式各自一份副本。 （进程的独立性）详情如下：

• 一开始创建子进程的时候，子进程和父进程的代码和数据共享，即相同的虚拟地址会映射到相同的物理地址空间。
• 当任意一方试图写入，便以写时拷贝的方式各自一份副本。比如：当子进程要修改父进程中的数据的时候，父进程中的数据会重新的拷贝一份，然后子进程再对数据进行修改。这样父子进程中的数据就独立了（进程独立性）

🔥 对于写时拷贝，有三个问题要注意：

1. 为什么要进行写时拷贝****❓1. 进程具有独立性。多进程运行，需要独享各种资源，多进程运行期间互不干扰，不能让子进程的修改影响到父进程
2. 为什么不在创建子进程的时候就直接在子进程中拷贝一份父进程中的代码和数据****❓1. 子进程不一定会修改父进程中的code或者data，只有当需要修改的时候，拷贝父进程中的数据才会有意义2. 这种按需分配的方式，也是一种延时分配，可以高效的时候使用内存空间和运行的效率
3. 父进程的代码段会不会进行拷贝****❓1. 一般情况下，子进程只会修改父进程副本的数据，不会对父进程的代码进行什么操作。但是当在进程替换的时候，子进程会拷贝一份父进程的代码段。

2.4 fork 调用失败原因

一般情况下****fork()函数不会调用失败，但是有两个情况下会使得fork()****创建子进程失败：

1. 系统中已经存在了很多的进程，内存空间不足以再创建进程了
2. 实际用户的进程超过了限制

2.5 fork 使用场景

1. 一个进程希望有多个进程执行一段代码的不同部分
2. 可以在一个进程中调用另一个进程，可以通过进程替换**exec**系列函数实现

3. 进程终止

了解进程创建之后，我们就要来了解一个进程的终止

进程终止做的事：

• 释放曾经的代码和数据所占据的空间
• 释放内核数据结构

3.1 进程终止的使用场景

进程需要终止退出的情况有三种：

1. 代码运行完毕，并且运行结果正确。（进程正常终止）
2. 代码运行完毕，并且运行结果不正确。（进程正常终止）
3. 进程崩溃（进程异常终止）

代码跑完，结果不正确的原因可以通过退出码确定，一旦出现异常，退出码就没有意义了，进程出异常，本质是因为进程收到了OS发给进程的信号。

3.2 进程退出码

3.2.1 进程退出码的理解

得到进程退出码有不止一种方式，但是这里介绍一种大家最熟悉的得到进程退出码的方式。

如果想要写一个C/C++程序的代码，写的第一个函数一定是****main()，而main()****是由返回值的。

• 而所谓的进程退出码就是以****main()****函数的返回值的形式返回的。
• 退出码为0表示代码执行成功，退出码为非0表示代码执行失败。
• 所以一般情况下，main()函数返回0，以表示代码执行成功。

下面两个问题可以帮助你更好地理解进程退出码的意义？

1. ****main()****的返回值给了谁❓ 1. ****main()函数也是一个函数，既然函数有返回值，那么该函数返回给了谁呢？要想搞清楚这个问题，就需要搞清楚到底是谁调用了main()函数2. 不同的平台下调用main()*函数的函数不同，但是最终*main()函数是由系统间接调用的，所以其实main()的返回值返回给了操作系统
2. 为什么****main()*函数要有返回值或者进程要有退出码❓ 1. 一个程序被加载到内存上，形成进程，是用来完成某项任务的。当进程完成任务后，我们需要知道进程完成任务的情况，因此需要通过退出码这种形式来得知进程执行任务的情况。*
3. 为什么退出码为 0 表示执行成功，非 0 表示执行错误❓ 1. 由于进程需要通过进程退出码的性质告诉外界自己完成任务的情况2. 如果进程成功的执行完任务正常退出，这种情况很好，并且这种情况值唯一的，所以用0就可以表示了3. 但是如果进程非正常退出，那么我们就需要知道进程为什么不正常退出，这时情况就比较复杂了，不正常退出的情况有很多， 例如内存空间不足、非法访问以及栈溢出等等。所以非正常退出的原因需要很多的数字来表示，因此就使用了非0来表示。

3.2.2 查看进程退出码

进程退出码有很多，每一个退出码都有对应的字符串含义，帮助用户确认执行失败的原因。

我们可以使用 **

$?

**来查看最近一个进程的退出码，如下：

echo $? # 打印出最近一个进程的退出码

如果想要知道每一种的进程退出码的含义， C语言当中的strerror函数可以通过错误码，获取该错误码在C语言当中对应的错误信息：

#include <cstdio>
#include <cstring>

int main()
{
    for (int i = 0; i < 10; i ++) {
        printf("第 %d 中进程退出码的含义: %s\n", i, strerror(i));
    }
    return 0;
}

运行结果如下：

注意：这些退出码具体代表什么含义是人为规定的，不同环境下相同的退出码的字符串含义可能不同

3.3 进程终止的方法

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

1. 从main返回，比如：return 0
2. 调用exit
3. _exit

3.3.1 return 退出

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

int main()
{
    printf("return 100\n");
    return 100;
}

运行结果如下：

3.3.2 _exit 退出

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

• 说明：虽然status是int，但是仅有低8位可以被父进程所用。所以_exit(-1)时，在终端执行$?发现返回值是255。

3.3.3 exit 退出

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

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

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

int main()
{
    printf("hello");
    exit(0);
}

运行结果(冲刷缓冲区):
[root@localhost linux]# ./a.out
hello[root@localhost linux]#

int main()
{
    printf("hello");
    _exit(0);
}

运行结果（直接退出）:
[root@localhost linux]# ./a.out
[root@localhost linux]#

3.3.4 三者区别

相似点：

• 通过return，exit()和_exit()都可以得到退出码。

不同点：

1. return：return只能在main()函数中返回才可以退出进程。
2. exit()：exit函数会执行用户定义的清理函数、冲刷缓冲，关闭流等操作，然后再终止进程，
3. _exit()：_exit()可以在任何的地方随时的退出进程，会直接终止进程，不会做任何收尾工作。

联系：

1. 在main()函数中的return等价于exit()
2. 在exit()中封装了_exit()函数。

****注意 return 和 exit ****区别

• exit()函数和return的功能差不多，但是exit()在任何的地方只要被调用，就会立即的退出进程
• *只有在*main()函数中return*才会退出进程，而*****exit()****在任意一个函数中都可以退出进程

**4. 进程等待 **

4.1 进程等待的必要性

• 「进程等待」的工作就是让父进程回收子进程的资源，获取子进程的退出信息。
• 因为如果子进程退出，父进程不读取子进程的退出信息回收子进程的资源的话，子进程就会变成僵尸进程，进而造成内存泄漏。
• 而一个进程变成僵尸进程的时候，就算是使用kill -9发送信号的方式也是不能回收该进程的资源的。

所以一定需要通过父进程通过进程等待的方式，来回收子进程的资源，同时为了搞清楚子进程完成任务的情况，也需要通过通过进程等待的方式获取子进程的退出信息。

4.2 子进程 status

在学习相关内容之前，我们先来理解一下子进程的 status 是啥意思，因为后面我们需要通过下面两个函数来做进程等待

• pid_t wait(int status)*
• pid_t waitpid(pid_t pid, int status, int options);*

我们发现这两个函数中都有一个参数status，而这个参数比较复杂且重要

4.2.1 status 的作用

🌈 上文说过，进程等待不仅是回收子进程的资源也需要获取子进程的退出信息，所以 status的作用就是获取退出的信息 。

status是一个输出型参数，即在wait()函数外面的变量，传入*wait() 函数，然后在wait() 内部对wait() 进行操作，从而改变status*

• 注意：如果不想要获取进程的退出信息的话，就可以用NULL替代status

4.2.2 status 的构造

⭐ status不能简单的当作整形来看待，可以当作位图来看待。 在status的后16个比特位上，高8位表示进程退出的状态，即进程退出码。而后7位为进程终止的信号。第8个比特位是一个标志

• 注意：当进程正常退出的时候，不用查看退出信号。而如果一个进程异常退出，即被信号杀死的话，不用看退出码

4.2.3 从 status 中获取退出信息

有两种方法我们可以获取status中的退出信息

方法一：位运算

如果已经知道了status中的比特位组成部分，我们就能通过位运算直接获取退出信息

int exit_code = (status >> 8) & 0xff; // 获取退出码
int exit_signal = status >> 0x7f; // 获取退出信号

方法二：使用宏

在系统中，提供了两个宏来获取提出码和退出信号

WIFEXITED(status); // 用于查看进程是否正常退出，其实就是查看是否有退出信号
WEXITSTATUS(status); // 用于获取进程的退出码

• 注意：当一个信号被杀死，进程等待是没有意义的

测试代码如下：

int main()
{
    pid_t pid;
    if ((pid = fork()) == -1)
        perror("fork"), exit(1);
    if (pid == 0) {
        sleep(20);
        exit(10);
    }
    else {
        int st;
        int ret = wait(&st);
        if (ret > 0 && (st & 0X7F) == 0) { // 正常退出
            printf("child exit code:%d\n", (st >> 8) & 0XFF);
        }
        else if (ret > 0) { // 异常退出
            printf("sig code : %d\n", st & 0X7F);
        }
    }
}
测试结果：
[root@localhost linux]# . / a.out #等20秒退出
child exit code : 10
[root@localhost linux]# . / a.out #在其他终端kill掉
sig code : 9

4.3 进程等待的方法

4.3.1 wait()

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int*status);
返回值：
    成功返回被等待进程pid，失败返回-1。
参数：
    status为输出型参数，通过传入一个参数来获取被等待的子进程的退出状态。不关心则可以设置成为NULL

4.3.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。

🌈 waitpid（）函数的作用是：等待指定的一个子进程或者任意一个进程。（这个可以有options参数控制）

1. status：输出型参数，获取子进程的退出信息，如果不需要进程退出的退出信息，可设置为NULL。
2. options：当 options 设置为0的时候，叫做阻塞等待。当 options 设置为 WNOWAIT 的时候，叫做非阻塞等待。（后面会有阻塞等待和非阻塞等待的例子）

下面分别对阻塞等待和非阻塞等待举出一个例子：

• 在子进程运行的时候，父进程在干什么呢？如果父进程就在那里等待子进程完成任务，接收子进程的退出信息的话，这种方式就是阻塞等待。就好像父进程被阻塞住不能前进一样。
• 如果父进程在子进程运行的时候，自己可以感自己的事情，这种方式就叫做非阻塞等待。

所以想要判断是否为阻塞或者非阻塞等待，就只要判断父进程在子进程运行的时候，可不可以自己运行自己的代码即可。

4.3.3 进程的阻塞等待方式

int main()
{
    pid_t pid;
    pid = fork();
    if (pid < 0) {
        printf("%s fork error\n", __FUNCTION__);
        return 1;
    }
    else if (pid == 0) { //child
        printf("child is run, pid is : %d\n", getpid());
        sleep(5);
        exit(257);
    }
    else {
        int status = 0;
        pid_t ret = waitpid(-1, &status, 0);//阻塞式等待，等待5S
        printf("this is test for wait\n");
        if (WIFEXITED(status) && ret == pid) {
            printf("wait child 5s success, child return code is :%d.\n", WEXITSTATUS(status));
        }
        else {
            printf("wait child failed, return.\n");
            return 1;
        }
    }
    return 0;
}
运行结果:
[root@localhost linux] # . / a.out
child is run, pid is : 45110
this is test for wait
wait child 5s success, child return code is : 1.

4.3.4 进程的非阻塞等待方式

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
    pid_t pid;
    pid = fork();
    if (pid < 0) {
        printf("%s fork error\n", __FUNCTION__);
        return 1;
    }
    else if (pid == 0) { //child
        printf("child is run, pid is : %d\n", getpid());
        sleep(5);
        exit(1);
    }
    else {
        int status = 0;
        pid_t ret = 0;
        do
        {
            ret = waitpid(-1, &status, WNOHANG);//非阻塞式等待
            if (ret == 0) {
                printf("child is running\n");
            }
            sleep(1);
        } while (ret == 0);
        if (WIFEXITED(status) && ret == pid) {
            printf("wait child 5s success, child return code is :%d.\n", WEXITSTATUS(status));
        }
        else {
            printf("wait child failed, return.\n");
            return 1;
        }
    }
    return 0;
}

5. 进程程序替换

5.1 替换原理

用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支)，子进程往往要调用一种exec函数以执行另一个程序。

当进程调用一种exec函数时

• 该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行
• 调用exec并不创建新进程,所以调用exec前后该进程的id并未改变

但是要注意两个问题❓

1. 当进程被另一个进程替换时，并没有创建一个新的进程 而只是在原来的进程的基础上，在进程的物理内存中代码和数据被另一个进程的代码和数据段所替换而已。其余的数据结构类似PCB，mm_struct，页表等等结构并没有改变。
2. 在子进程进行程序替换之后，父进程中的代码段和数据段并没有受到任何的影响。 1. 因为当子进程在进行进程替换时，需要对进程的数据和代码段进程修改，这时进程会发生写时拷贝，而在写时拷贝之后，父子进程的代码和数据独立了，所以相互之间的数据和代码不会受到影响。

5.2 替换函数

进程替换函数是exec系列函数，而这一系列的函数一共有6个函数。

#include <unistd.h>
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[]);

#include <unistd.h>

int main()
{
    char *const argv[] = {"ps", "-ef", NULL};
    char *const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL};
    
    execl("/bin/ps", "ps", "-ef", NULL);
    
    // 带p的，可以使用环境变量PATH，无需写全路径
    execlp("ps", "ps", "-ef", NULL);
    
    // 带e的，需要自己组装环境变量
    execle("ps", "ps", "-ef", NULL, envp);
    
    execv("/bin/ps", argv);
    
    // 带p的，可以使用环境变量PATH，无需写全路径
    execvp("ps", argv);
    
    // 带e、p的，需要自己组装环境变量，无需写全路径
    execvpe("ps", argv, envp);
    
    // 带e的，需要自己组装环境变量
    execve("/bin/ps", argv, envp);
    
    exit(0);
}

我们来对上面的 execl 来进行分析，其他的大家可以自行去实践

int execl(const char path, const char arg, ...)**

函数参数

• path：要替换的可执行程序所在的路径
• arg：给可执行程序传递的命令行参数（是一个可变参数列表），最后要以NULL结尾。
• 函数返回值 - 如果execl执行成功，则进程替换成功，那么就没有返回值，因为进程已经执行其他进程了- 如果execl执行失败，则返回 -1

情况一：只调用系统中的可执行程序

#include <cstdio>
#include <sys/types.h>
#include <sys/wait.h>
#include <cstdlib>
#include <unistd.h>

int main()
{
    pid_t pid = fork();
    if (pid == 0) {
        // “/usr/bin/ls"是可执行文件的路径
        // "ls", "-a", "-l", "-i"是执行的方式
        // 就好像是直接在命令行中敲 ls -a -l -i样
        execl("/usr/bin/ls", "ls", "-a", "-l", "-i", NULL);
        exit(1);
    } else { 
        // 进程等待，父进程回收子进程资源
        int status = 0;
        pid_t res = waitpid(pid, &status, 0);
        if (res > 0) {
            printf("wait child process success!\n");
            if (WIFEXITED(status)) {
                printf("exit code: %d\n", WEXITSTATUS(status));
            } else {
                printf("exit signal: %d\n", status & 0x7f);
            }
        }
    }
    return 0;
}

运行结果如下：

情况二：****不只调用系统中的可执行程序，还利用一个自己写的程序去直接调用自己写的另一个程序

// hello.cpp
#include <iostream>

int main()
{
    std::cout << "hello world" << std::endl;
    return 0;
}

// test.c
#include <cstdio>
#include <sys/types.h>
#include <sys/wait.h>
#include <cstdlib>
#include <unistd.h>

int main()
{
    pid_t pid = fork();
    if (pid == 0) {
        // “./hello"是可执行文件的路径
        // "hello"是执行的方式
        execl("./hello", "hello", NULL);
        exit(1);
    } else { 
        // 进程等待，父进程回收子进程资源
        int status = 0;
        pid_t res = waitpid(pid, &status, 0);
        if (res > 0) {
            printf("wait child process success!\n");
            if (WIFEXITED(status)) {
                printf("exit code: %d\n", WEXITSTATUS(status));
            } else {
                printf("exit signal: %d\n", status & 0x7f);
            }
        }
    }
    return 0;
}

运行结果如下：

5.3 替换函数解释

通过上面六个函数的学习，大家一定可以发现其中其实存在一些规律，他们的后缀函数如下：

• l(list)：表示参数采用列表的形式列出，通过函数参数逐个给与，最终以NULL结尾

• v(vector)：表示参数采用数组的形式列出，通过字符指针数组一次性给与。

• p(path)：表示执行程序可以自动在环境变量PATH中自动搜索可执行程序的路径， - 没有 p 的需要指定路径- 有p的会默认到 path 环境变量指定路径下寻找。

• e(env)：表示自己可以传入自己写的环境变量 - 没有 e 则默认使用父进程环境变量- 有 e 则自定义环境变量。
  函数名参数格式是否要写成绝对路径是否使用当前的环境变量execl列表✔️✔️execlp列表×（文件名即可）✔️execle列表✔️×（自己设置环境变量）execv数组✔️✔️execvp数组×（文件名即可）✔️execve数组✔️×（自己设置环境变量）

• 事实上：其实execve才是真正的系统调用，其他的几个函数只不过对于execve进行了封装。以满足不同的调用需求。

小结 📖

【★,°*:.☆(￣▽￣)/$:*.°★ 】那么本篇到此就结束啦，如果我的这篇博客可以给你提供有益的参考和启示，可以三连支持一下 💖！💞**