【Linux】进程控制

发布时间：2024年01月18日

进程控制

一、进程创建
二、进程终止
三、进程等待
四、进程程序替换
五、制作一个简易的shell

一、进程创建

1、fork函数初识

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

返回值：
在子进程中返回0，父进程中返回子进程的PID，子进程创建失败返回-1。

进程调用fork，当控制转移到内核中的fork代码后，内核做：
1.分配新的内存块和内核数据结构给子进程
2.将父进程部分数据结构内容拷贝至子进程
3.添加子进程到系统进程列表当中
4.fork返回，开始调度器调度

在这里插入图片描述

运行结果：

在这里插入图片描述

我们根据运行结果发现，在没有进行fork之前，只打印了一个Before的id，因为这是在fork之前只有一个进程进行操作，而fork后则有两个进程了，一个是父进程一个是子进程，所以会有两个After，但我们需要注意一点是子进程先跑还是父进程先跑完全取决于调度器。
在这里插入图片描述

2、fork函数返回值

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

（1）fork函数为什么要给子进程返回0，给父进程返回子进程的PID

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

（2）fork()函数为什么有两个返回值

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

在这里插入图片描述
也就是说，在fork函数内部执行return语句之前，子进程就已经创建完毕了，那么之后的return语句不仅父进程需要执行，子进程也同样需要执行，这就是fork函数有两个返回值的原因。

3、写时拷贝

当子进程刚刚被创建时，子进程和父进程的数据和代码是共享的，即父子进程的代码和数据通过页表映射到物理内存的同一块空间。只有当父进程或子进程需要修改数据时，才将父进程的数据在内存当中拷贝一份，然后再进行修改。

在这里插入图片描述
衍生出三个问题：

（1）为什么要进行写时拷贝

进程具有独立性。多进程运行，需要独享各种资源，多进程运行期间互不干扰，不能让子进程的修改影响到父进程。

（2）为什么不在创建子进程的时候就进行数据的拷贝

子进程不一定会使用父进程的所有数据，并且在子进程不对数据进行写入的情况下，没有必要对数据进行拷贝，我们应该按需分配，在需要修改数据的时候再分配，这样可以高效的使用内存空间。

（3）代码会不会进行写时拷贝

90%的情况下是不会的，但这并不代表代码不能进行写时拷贝，例如在进行进程替换的时候，则需要进行代码的写时拷贝。

4、fork的常规用法

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

5、fork调用失败的原因

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

二、进程终止

1、进程退出场景

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

2、进程退出码

我们都知道main函数是进入函数代码的入口，而我们却不知道的一点，实际上main函数只是用户级别代码的入口，main函数也是被其他函数调用的，例如在VS2013当中main函数就是被一个名为__tmainCRTStartup的函数所调用，而__tmainCRTStartup函数又是通过加载器被操作系统所调用的，也就是说main函数是间接性被操作系统所调用的。

既然我们的main函数是被间接调用的，那肯定是有返回值的，那么当main函数调用结束后就应该给操作系统返回相应的退出信息，而这个所谓的退出信息就是以退出码的形式作为main函数的返回值返回，我们一般以0表示代码成功执行完毕，以非0表示代码执行过程中出现错误，这就是为什么我们都在main函数的最后返回0的原因。

我们看下面的代码：通过echo $?来看一下我们的返回码：
在这里插入图片描述

为什么0表示退出码成功，而非零表示失败呢？

原因是因为，成功只有一种，而不成功则有很多种原因，所以，我们通过非零的退出码来表示退出失败。

运行代码后我们就可以看到各个错误码所对应的错误信息：

strerror函数：

实际上linux中的pwd,ls也是可执行程序，使用这些命令后我们也可以查看其对应的退出码。

在这里插入图片描述

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

3、exit&&_exit

（1）exit

我们经常用exit这个函数，因为这个函数是可以进行调用来进行退出的函数，exit函数可以在代码中的任何地方退出进程，并且exit函数在退出进程前会做一系列工作：

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

在这里插入图片描述

（2）_exit

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

在这里插入图片描述

（3）return && exit && _exit区别与联系

i、区别

在main函数中只有return才是退出，而在子函数中return不能退出，而exit和_exit都可以在任何的位置进行退出进程的作用。

使用exit函数退出进程前，exit函数会执行用户定义的清理函数、冲刷缓冲，关闭流等操作，然后再终止进程，而_exit函数会直接终止进程，不会做任何收尾工作。

在这里插入图片描述

ii、联系

联系密切，当main函数return的时候，也就是退出的时候，return num 等同于 exit(num)，因为调用main函数运行结束后，会将main函数的返回值当做exit的参数来调用exit函数。

当exit函数退出进程前，exit函数会先执行用户定义的清理函数、冲刷缓冲，关闭流等操作，然后再调用_exit函数终止进程。

4、进程异常退出

向进程发生信号导致进程异常退出。
在进程运行过程中向进程发生kill -9信号使得进程异常退出，或是使用Ctrl+C使得进程异常退出等。

代码错误导致进程运行时异常退出。
代码当中存在野指针问题使得进程运行时异常退出，或是出现除0的情况使得进程运行时异常退出等。

三、进程等待

1、进程等待必要性

如果子进程退出，父进程如果不读取子进程的退出信息，子进程就会变成僵尸进程，进而造成内存泄漏。
进程一旦变成了僵尸进程，变成刀枪不入的战甲了，就是kill -9来了都无济于事，因为谁也不能杀死一个已经死去的进程。
最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。
父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息

2、获得子进程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)：用于获取进程的退出码。

3、进程等待的方法

（1）wait方法

函数原型：pid_t wait(int* status);

作用：等待任意子进程。

返回值：等待成功返回被等待进程的pid，等待失败返回-1。

参数：输出型参数，获取子进程的退出状态，不关心可设置为NULL。

如下图：我们父进程一直等待着子进程，直到子进程都跑完了，父进程进行回收，然后一起退出，这样子进程就不会变成僵尸进程了。

#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)
    {
        // child
        int count = 10;
        while(count--)
        {
            printf("[count]{%d}I am child process...pid:%d, ppid:%d\n", count, getpid(), getppid());
            sleep(1);
        }
        exit(0);
    }
    // father
    int status = 0;
    pid_t ret = wait(&status);
    if(ret > 0)
    {
        // wait sucess
        printf("wait sucess\n");
        if(WIFEXITED(status))
        {
			//exit normal
			printf("exit code:%d\n", WEXITSTATUS(status));
		}
    }
    return 0;
}

在这里插入图片描述

（2）waitpid方法

函数原型：pid_ t waitpid(pid_t pid, int *status, int options);

作用：等待指定子进程或任意子进程。

返回值：
当正常返回的时候waitpid返回收集到的子进程的进程ID；
如果设置了选项WNOHANG，而调用中waitpid发现没有已退出的子进程可收集，则返回0；
如果调用中出错，则返回-1，这时errno会被设置成相应的值以指示错误所在；

参数：

1、pid：
Pid=-1,等待任一个子进程。与wait等效。
Pid>0.等待其进程ID与pid相等的子进程。
2、status:（不关心一般返回NULL）
WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）
WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）
3、options:
WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。

创建子进程后，父进程可使用waitpid函数一直等待子进程（此时将waitpid的第三个参数设置为0），直到子进程退出后读取子进程的退出信息。

#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)
    {
        // child
        int count = 10;
        while(count--)
        {
            printf("[count]{%d}I am child process...pid:%d, ppid:%d\n", count, getpid(), getppid());
            sleep(1);
        }
        exit(0);
    }
    // father
    int status = 0;
    pid_t ret = waitpid(id, &status, 0);
    if(ret >= 0)
    {
        // wait success
        printf("wait child sucess...\n");
        if (WIFEXITED(status))
        {
			// exit normal                                 
			printf("exit code:%d\n", WEXITSTATUS(status));
		}
		else
        {
			// signal killed                              
			printf("killed by siganl %d\n", status & 0x7F);
		}
    }
    return 0;
}

在这里插入图片描述

（3）补充信息

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

4、多进程创建以及等待的代码模型

这个很简单，我们只需要设置一个idex的数组，创建出来十个子进程，退出码为i，每个都是从0开始递增到10的，让父进程依次等待子进程退出，这叫做多进程创建以及等待的代码模型。

以下代码中同时创建了10个子进程，同时将子进程的pid放入到idex数组当中，并将这10个子进程退出时的退出码设置为该子进程pid在数组ids中的下标，之后父进程再使用waitpid函数指定等待这10个子进程。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#define MAW 10
int main()
{
    pid_t idex[MAW];
    for(int i = 0; i < 10; i++)
    {
        pid_t id = fork();
        if(id == 0)
        {
            // child
            printf("child is created sucessfully...\n");
            sleep(1);
            exit(i);
        }
        // father
        idex[i] = id;
    }
    for(int i = 0; i < 10; i++)
    {
        int status = 0;
        pid_t ret = waitpid(idex[i], &status, 0);
        if(ret >= 0)
        {
            // wait sucess
            printf("wait child sucess...\n");
            if(WIFEXITED(status))
            {
                // exit normal
                printf("exit code:%d\n", WEXITSTATUS(status));
            }
            else
            {
                // signed kill
                printf("signed killed sucess...:%d\n", status & 0x7F);
            }
        }
    }
    return 0;
}

运行代码，这时我们便可以看到父进程同时创建多个子进程，当子进程退出后，父进程再依次读取这些子进程的退出信息。
在这里插入图片描述

5、基于非阻塞接口的轮询检测方案

我们从上面的截图中看到，子进程创建完了以后需要退出了，是一个退出信息给父进程，父进程去接收，然后再双双退出，而父进程不能做任何事情，那么我们称之为阻塞状态，也就是阻塞等待。
而实际上我们还有另外一种做法是让父进程在等待子进程退出的时候干些别的工作，也就是子进程未退出的时候父进程去干别的事情，子进程退出的时候，父进程在通过wair或者是waitpid去接收再双双退出。

向waitpid函数的第三个参数potions传入WNOHANG，这样一来，等待的子进程若是没有结束，那么waitpid函数将直接返回0，不予以等待。而等待的子进程若是正常结束，则返回该子进程的pid。

父进程可以隔一段时间调用一次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("[count]:{%d}child is doing somthing...:getpid():%d, 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("child wait sucess...\n");
            printf("exit code:%d\n", WEXITSTATUS(status));
            break;
        }
        else if(ret == 0)
        {
            // father do something
            printf("father do something...\n");
            sleep(1);
        }
        else
        {
            // error
            printf("error...\n");
            break;
        }
    }
    return 0;
}

父进程每隔一段时间就去查看子进程是否退出，若未退出，则父进程先去忙自己的事情，过一段时间再来查看，直到子进程退出后读取子进程的退出信息。
在这里插入图片描述

四、进程程序替换

1、概念和现象

用fork创建子进程后，子进程执行的是和父进程相同的程序，若想让子进程执行另一个程序，往往需要调用一种exec函数。
当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新程序替换，并从新程序的启动例程开始执行。

在这里插入图片描述

问题1：当进行进程程序替换时，有没有创建新的进程？
进行程序替换后，仅仅是磁盘将其要执行的程序中的数据和代码将物理内存中的代码和数据进行替换，而并没有改变进程的pcb，进程地址空间以及页表等数据结构都没有变，只是进程在物理内存当中的数据和代码发生了改变，所以并没有创建新的进程，而且进程程序替换前后该进程的pid并没有改变。

问题2：子进程进行进程程序替换后，会影响父进程的代码和数据吗？
当然不会影响了，进程具有独立性呀！最关键的一点在于进程会写时拷贝的呀！当子进程被父进程fork的时候，也就是子进程被创建的时候，此时子进程是共享父进程的代码和数据的，而当子进程进行进程程序替换的时候，也就是意味着子进程被写入了，所以子进程和父进程所共享的代码和数据需要进行写时拷贝了，这就确保了进程的独立性，然后父子进程的代码也就分离了，因此子进程进行程序替换后不会影响父进程的代码和数据。

2、替换函数

有六种以exec开头的函数,统称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[]);

（1）execl函数

int execl(const char *path, const char *arg, …);

第一个参数是路径，表示这个参数要执行程序的路径，第二个参数是可变参数列表，这个参数是可以很多个的，表示你可以如何执行这个程序，最后一个是…为NULL结尾。

我们用ls这个命令来进行看一下：
在这里插入图片描述

（2）execlp

int execlp(const char *file, const char *arg, …);

第一个参数是要执行的程序的名字，第二个参数是可变参数列表，这个参数同样是可以很多个的，表示你可以如何执行这个程序，最后一个…是NULL结尾。

我们继续用ls这个命令来进行看一下：
在这里插入图片描述

（3）execle

int execle(const char *path, const char *arg, …, char *const envp[]);

第一个参数是路径，第二个参数是可变参数列表，这个参数同样是可以很多个的，表示你可以如何执行这个程序，最后一个…是NULL结尾，而第三个参数是你自己设置的环境变量。

设置了MYVAL环境变量，在mycmd程序内部就可以使用该环境变量。
在这里插入图片描述

（4）execv

int execv(const char *path, char *const argv[]);

第一个参数是路径，第二个参数是一个指针数组，数组当中的内容表示你要如何执行这个程序，数组以NULL结尾。

ls命令：
在这里插入图片描述

（5）execvp

int execvp(const char *file, char *const argv[]);

第一个参数是要执行程序的名字，第二个参数是一个指针数组，数组当中的内容表示你要如何执行这个程序，数组以NULL结尾。

在这里插入图片描述

（6）execve

int execve(const char *path, char *const argv[], char *const envp[]);

第一个参数是要执行程序的路径，第二个参数是一个指针数组，数组当中的内容表示你要如何执行这个程序，数组以NULL结尾，第三个参数是你自己设置的环境变量。

在这里插入图片描述

3、函数解释

这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。
如果调用出错则返回-1
所以exec函数只有出错的返回值而没有成功的返回值。

4、命名解释

l(list) : 表示参数采用列表
v(vector) : 参数用数组
p(path) : 有p自动搜索环境变量PATH
e(env) : 表示自己维护环境变量

在这里插入图片描述

而事实上，只有execve才是真正的系统调用，其它五个函数最终都是调用的execve，所以execve在man手册的第2节，而其它五个函数在man手册的第3节，也就是说其他五个函数实际上是对系统调用execve进行了封装，以满足不同用户的不同调用场景的。

在这里插入图片描述

五、制作一个简易的shell

shell也就是命令行解释器，其运行原理就是：当有命令需要执行时，shell创建子进程，让子进程执行命令，而shell只需等待子进程退出即可。

流程图：
在这里插入图片描述

信息：
while(1)
{
1、获取命令行
2、解析命令行
3、创建子进程
4、替换子进程
5、等待子进程并退出
}

其中，创建子进程使用fork函数，替换子进程使用exec系列函数，等待子进程使用wait或者waitpid函数。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#define LEFT "["        // 左括号
#define RIGHT "]"       // 右括号
#define LABLE "#"       // 提示符
#define DELIM " \t"     // 空格符
#define LINE_SIZE 1024  // 命令最长长度
#define ARGC_SIZE 32    // 分割
#define EXIT_CODE 44    // 退出码

// 最后代码
int lastcode = 0;
// 退出
int quit = 0;
// 环境变量
extern char **environ;
// 分割
char commandline[LINE_SIZE];
// 变量
char *argv[ARGC_SIZE];
// 路径
char pwd[LINE_SIZE];
// 自定义的环境变量
char myenv[LINE_SIZE];

// 调用环境变量函数调用username和hostname
const char* getusername()
{
    return getenv("USER");      // 环境变量中本来就有
}
const char* gethostname()
{
    return getenv("HOSTNAME");  // 环境变量中本来就有
}
void getpwd()
{
    getcwd(pwd, sizeof(pwd));   // 传上面的全局变量
}

// 获取命令行函数
void GetCommandLine(char* cline, int sz)
{
    // 调用路径
    getpwd();
    // 打印输出
    printf(LEFT"%s@%s %s"RIGHT""LABLE" ", getusername(), gethostname(), pwd); // 打印出输出的格式
    // 用键盘进行输入指令了
    char* s = fgets(cline, sz, stdin); // 键盘输入
    assert(s);
    (void)s; // 将s这个字符串强转成void以及断言一下，不能让s啥也没输入
    // 将最后一个字符的下一个位置填入\0
    cline[strlen(cline) - 1] = '\0'; // 防止越界
}

// 分割字符串
int splitstring(char* cline, char** _argv)
{
    int i = 0;
    argv[i++] = strtok(cline, DELIM);
    while(_argv[i++] = strtok(NULL, DELIM)); // 故意写的=
    return i - 1;
}

// 指令的判断，即创建进程判断是内建命令还是普通命令
int AdjustCommand(char* _argc, char** _argv)
{
    // 我们写一下下面三个命令的指令
    if(_argc == 2 && strcmp(_argv[0], "cd") == 0)          // 进入目录
    {
        chdir(_argv[1]);      // 改变目录地址
        getpwd();             // 获取目录
        sprintf(getenv("PWD"), "%s", pwd); // 从环境变量中获取地址并打印出来
        return 1;
    }
    else if(_argc == 2 && strcmp(_argv[0], "export") == 0) // 设置环境变量
    {
        strcpy(myenv, _argv[1]); // 将输入的环境变量复制到系统的环境变量中
        putenv(myenv);
        return 1;
    }
    else if(_argc == 2 && strcmp(_argv[0], "echo") == 0)   // 打印
    {
        if(strcmp(_argv[1], "$?") == 0) // 有可能使用？来看一下有些啥
        {
            printf("%d\n", lastcode);
            lastcode = 0;
        }
        else if(*_argv[1] == '$') // 打印不同的系统指令
        {
            char *val = getenv(_argv[1] + 1);
            if(val) 
                printf("%s\n", val);
        }
        else
        {
            printf("%s\n", _argv[1]);
        }
        return 1;
    }
    return 0;
}

// 普通命令
void NormalExcute(char** _argv)
{
    pid_t id = fork();
    if(id < 0)
    {
        perror("fork error");
        return;
    }
    else if(id == 0)
    {
        //让子进程执行命令
        execvpe(_argv[0], _argv, environ);
        exit(EXIT_CODE);
    }
    else
    {
        // 父进程等待
        int status = 0;
        pid_t rid = waitpid(id, &status, 0);
        if(rid == id) 
        {
            lastcode = WEXITSTATUS(status);
        }
    }
}

int main()
{
    while(!quit)
    {
        // 1. 交互问题，获取命令行 传参数为命令行+命令行的大小
        GetCommandLine(commandline, sizeof(commandline));

        // 2. 子串分割的问题，解析命令行
        int argc = splitstring(commandline, argv); // 进行分割，分割成功了则返回非零数，解析不成功则返回0
        if(argc == 0) 
            continue;

        // 3. 指令的判断 
        int n = AdjustCommand(argc, argv); //内键命令，本质就是一个shell内部的一个函数

        // ls -a -l | wc -l
        // 3.0 分析输入的命令行字符串，获取有多少个|, 命令打散多个子命令字符串
        // 3.1 malloc申请空间，pipe先申请多个管道
        // 3.2 循环创建多个子进程，每一个子进程的重定向情况。最开始. 输出重定向, 1->指定的一个管道的写端 
        // 中间：输入输出重定向， 0标准输入重定向到上一个管道的读端 1标准输出重定向到下一个管道的写端
        // 最后一个：输入重定向，将标准输入重定向到最后一个管道的读端
        // 3.3 分别让不同的子进程执行不同的命令--- exec* --- exec*不会影响该进程曾经打开的文件，不会影响预先设置好的管道重定向
        // 4. 普通命令的执行
        if(!n)
            NormalExcute(argv);
    }
    return 0;
}

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

文章来源:https://blog.csdn.net/m0_70088010/article/details/135622174
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！