【Linux从入门到精通】进程的控制（进程替换）

缺乏、安全感 2024-04-22 22:19 94阅读 0赞

![22c974c5fb1e4ae8ab0d2094664de93e.gif][]

> 本篇文章会对进程替换进行讲解。希望本篇文章会对你有所帮助

> **文章目录**
> 
> 一、进程替换概念
> 
> 二、进程替换函数
> 
> 2、1 execl
> 
> 2、2 execlp
> 
> 2、3 execv
> 
> 2、3 execle
> 
> 2、4 execve
> 
> 三、总结
> 
> --------------------
> 
> **?♂️ 作者：@Ggggggtm ?♂️**
> 
> **? 专栏：Linux从入门到精通 ?**
> 
> **? 标题：进程控制?**
> 
>  **❣️ 寄语：与其忙着诉苦，不如低头赶路，奋路前行，终将遇到一番好风景 ❣️** ![5ae04542110a4e3ba3ee2675404ac4b5.png][]

## 一、进程替换概念 ##

> 我们知道，fork() 创建子进程，子进程的代码和数据是和父进程共享一份的。当对任意一个进程修改时，就会发生写时拷贝。当时我们就想让子进程执行一份全新的代码呢？那我们可以使用进程替换。
> 
> 程序替换就是使用一个接口来实现的。把磁盘上的可执行程序加载到进程的地址空间上。可结合下图理解：
> 
> ![50c35a35310e483c9e19746d25f52f0a.png][]
> 
> 进程替换**就是把磁盘上的可执行程序加载到了内存中已经在运行的进程中，加载上的新程序会与原来的进程的页表构成新的映射关系，实际上并没有创建新的进程**。

## 二、进程替换函数 ##

### 2、1 execl ###

> 我们先来看一下execl（）函数怎么使用，如下图：
> 
> ![61a85e11651a4281b68a3dba4c58fac3.png][]
> 
> **第一个参数是指你所要替换程序的路径。后面的参数是要怎么执行该程序，是一个可变参数列表，但是最后一个参数必须为空**。具体使用如下：
> 
>     #include<stdio.h>    
>     #include<unistd.h>    
>     #include<stdlib.h>    
>         
>     int main()    
>     {    
>         printf("hello linux\n");    
>         
>         execl("/usr/bin/ls","ls","-l",NULL);                                                                                                                     
>         
>         printf("hello linux\n");    
>         
>         exit(111);    
>         return 0;    
>     }
> 
> 我们看如下运行结果：
> 
> ![c32c23ff3c78415ea7f19fbfeea3be84.png][]
> 
> 确实执行了ls -l 的命令，但是并没有往下接着执行打印和退出！！！怎么没有打印呢？execl是程序替换，调用该函数后，会将当前的进程所有代码和数据进行替换。所以一旦调用成功，后续的代码将不会在被执行。
> 
> `exec()`系列函数在成功时不会返回，只有在发生错误时才会返回-1。这是因为当`exec()`函数成功地加载新的可执行程序后，它会在当前进程上下文中完全替换掉当前进程的映像，包括代码、数据、堆栈等。这使得原先的进程状态被新的可执行程序取代，所以在成功加载新程序后，旧程序不再存在，也就无法进行返回操作了。

### 2、2 execlp ###

> execlp函数对比execl函数，就是所要替换的程序可以自己不带路径。execlp中的 p 指的意思是环境变量PATH，可以默认去找所要替换的程序路径。代码如下：
> 
>     #include<stdio.h>    
>       #include<unistd.h>    
>       #include<stdlib.h>    
>           
>       int main()    
>       {    
>           printf("hello linux\n");    
>           
>           //execl("/usr/bin/ls","ls","-l",NULL);    
>           execlp("ls","ls","-l","-a",NULL);                                                                                                                      
>                                                                          
>           printf("hello linux\n");        
>                                           
>           exit(111);                      
>           return 0;                       
>       }
> 
> 运行结果如下：
> 
> ![6a34bdf7081645f3823f6415e39ba0ff.png][]

### 2、3 execv ###

> 我们再来看一下execv函数的使用。如下图：
> 
> ![2d1b9e2a004f404d9c14136f8e0b212d.png][]
> 
> 其实对比execl函数不难发现，l 表示list的意思，也就是参数列表一个一个列出来。execv函数中的 v 表示vector，参数列表是一个数组。我们可看如下代码：
> 
>     #include<stdio.h>    
>       #include<unistd.h>    
>       #include<stdlib.h>    
>           
>       char* const _argv[]={"ls","-l","-a",NULL};                                                                                                                 
>           
>       int main()    
>       {    
>           printf("hello linux\n");    
>           
>           //execl("/usr/bin/ls","ls","-l",NULL);    
>           
>           execv("/usr/bin/ls",_argv);    
>           printf("hello linux\n");    
>           
>           exit(111);    
>           return 0;    
>       }
> 
> 运行结果如下：
> 
> ![44b12de058b84d179b77742865a6a58c.png][]

### 2、3 execle ###

> 我们这里就不再解释execvp了，对比上述讲到很容易理解。直接看execle函数。我们先看execle函数怎么使用：
> 
> ![f5e1730a8f864724bd08282f1a3241fc.png][]
> 
> 其实我们也不难发现，对比execl函数，参数列表最后多出来一个指针数组。这个指针数组就是维护的环境变量。为了更好的演示该函数，我们先写一下一个我们自己生成的可执行程序去调用我们另一个自己生成的可执行程序。代码如下：
> 
>     //“————————————————myexec.c————————————————————”
>       #include<stdio.h>    
>       #include<unistd.h>    
>       #include<stdlib.h>    
>           
>       const char* myflie="/home/gtm/primer/test/test_7_23/mycmd";    
>       int main(int argc,char* argv[],char* env[])                                                                                                                
>       {    
>           printf("hello linux\n");    
>           
>           //execl("/usr/bin/ls","ls","-l",NULL);    
>           //execlp("ls","ls","-l","-a",NULL);    
>           
>           execle(myflie,"mycmd","-a",NULL,env);    
>           //execv("/usr/bin/ls",_argv);    
>           return 0;    
>       }  
>     
>     //“————————————————mycmd.c————————————————————”
>     #include <stdio.h>
>     #include <string.h>
>     #include <stdlib.h>
>     
>     // ./mycmd -a/-b/-c...
>     int main(int argc, char *argv[])
>     {
>         if(argc != 2)
>         {
>             printf("can not execute！\n");
>             exit(1);
>         }
>     
>         //MY_105_VAL: 目前并不存在！
>         printf("获取环境变量: hello: %s\n", getenv("hello"));
>                                                                                       
>         if(strcmp(argv[1], "-a") == 0)                                            
>         {                                                                         
>             printf("hello a!\n");                                                 
>         }                                                                         
>         else if(strcmp(argv[1], "-b") == 0)                                       
>         {                                                                         
>             printf("hello b!\n");                                                 
>         }                                                                                                                                                        
>         else{                                                                     
>             printf("default!\n");                                                 
>         }                                                                                      
>                                                                                   
>         return 0;                                                                 
>     }
> 
> 上述代码是在不同的源文件，上述代码中有所标述。我们想要的就是用myexec去调用mycmd。我们在mycmd中想要获取环境变量 hello 的值，但是哦我们并没有设置。所以环境变量hello的值为null。我们看运行结果：
> 
> ![e62b25abd24244e7b45495dcdc005c44.png][]
> 
> 但是我们要在myexec中设置了hello环境变量，
> 
>     #include<stdio.h>    
>       #include<unistd.h>    
>       #include<stdlib.h>    
>           
>       const char* myflie="/home/gtm/primer/test/test_7_23/mycmd";    
>       int main(int argc,char* argv[],char* env[])    
>       {    
>           printf("hello linux\n");    
>           
>           //execl("/usr/bin/ls","ls","-l",NULL);    
>           //execlp("ls","ls","-l","-a",NULL);    
>           
>           const char* _env[]={"hello=20230724",NULL};    
>           execle(myflie,"mycmd","-a",NULL,_env);                                                                                                                 
>           //execv("/usr/bin/ls",_argv);    
>           return 0;    
>       }
> 
> 我们再来看运行结果：
> 
> ![6fff9dade215413690e912dfb9be3585.png][]
> 
> 当然，环境变量hello就可以获取相应的值。

### 2、4 execve ###

> execve函数是属于系统调用函数。我们上述讲到的，如下图：
> 
> ![815fae8ed1ce4900866f6c9b459f6573.png][]
> 
> 都是语言级别的函数，底层封装的都是execve函数。事实上,只有execve是真正的系统调用,其它五个函数最终都调用 execve。为什么还要封装呢？直接使用execve多好啊。原因是封装后，我们也可以很直接的感受到，应用的场景变多了。其次是用起来，见名知其意。

## 三、总结 ##

> 在C++中，exec()系列函数提供了一种在程序中执行外部命令或可执行文件的方法。这些函数包括：execvp()、execv()、execvpe()、execlp()、execl()、execle()和execve()。
> 
> 1.  execvp()函数：
>     
>      *  原型：int execvp(const char \*file, char \*const argv\[\]);
>      *  功能：用于在指定的文件路径中搜索可执行文件，并用指定的参数列表运行该文件。
>      *  优点：可以直接使用文件名作为参数，而无需提供文件路径。
>      *  返回值：如果函数执行成功，则不会返回任何值；如果函数执行失败，则会返回-1。
> 2.  execv()函数：
>     
>      *  原型：int execv(const char \*path, char \*const argv\[\]);
>      *  功能：在指定的文件路径中搜索可执行文件并用指定的参数列表运行该文件。
>      *  优点：需要提供文件路径，因此可以明确指定要执行的文件的位置。
>      *  返回值：如果函数执行成功，则不会返回任何值；如果函数执行失败，则会返回-1。
> 3.  execvpe()函数：
>     
>      *  原型：int execvpe(const char \*file, char \*const argv\[\], char \*const envp\[\]);
>      *  功能：在指定的文件路径和环境变量中搜索可执行文件，并用指定的参数列表运行该文件。
>      *  优点：除了搜索文件路径外，还可以指定环境变量。
>      *  返回值：如果函数执行成功，则不会返回任何值；如果函数执行失败，则会返回-1。
> 4.  execlp()函数：
>     
>      *  原型：int execlp(const char \*file, const char \*arg, ...);
>      *  功能：在系统的环境变量所指定的路径中搜索可执行文件并用指定的参数列表运行该文件。
>      *  优点：可以直接使用文件名和参数作为参数，而无需提供文件路径。
>      *  返回值：如果函数执行成功，则不会返回任何值；如果函数执行失败，则会返回-1。
> 5.  execl()函数：
>     
>      *  原型：int execl(const char \*path, const char \*arg, ...);
>      *  功能：在指定的文件路径中搜索可执行文件并用指定的参数列表运行该文件。
>      *  优点：需要提供文件路径和参数，因此可以明确指定要执行的文件的位置和所需的参数。
>      *  返回值：如果函数执行成功，则不会返回任何值；如果函数执行失败，则会返回-1。
> 6.  execle()函数：
>     
>      *  原型：int execle(const char \*path, const char \*arg, ..., char \*const envp\[\]);
>      *  功能：在指定的文件路径和环境变量中搜索可执行文件，并用指定的参数列表运行该文件。
>      *  优点：除了搜索文件路径外，还可以指定环境变量。
>      *  返回值：如果函数执行成功，则不会返回任何值；如果函数执行失败，则会返回-1。
> 7.  execve()函数：
>     
>      *  原型：int execve(const char \*filename, char \*const argv\[\], char \*const envp\[\]);
>      *  功能：在指定的文件路径和环境变量中搜索可执行文件，并用指定的参数列表运行该文件。
>      *  优点：需要提供文件路径和参数，以及环境变量，因此可以明确指定要执行的文件的位置、所需的参数和运行环境。
>      *  返回值：如果函数执行成功，则不会返回任何值；如果函数执行失败，则会返回-1。
> 
> ![42ed61559e4d474fb9a68f7f76fdb709.png][]
> 
> exec()系列函数允许程序在运行时调用其他可执行文件，以实现更复杂的功能。这些函数提供了不同的方式来指定可执行文件的路径、传递参数和设置环境变量，根据具体的需求，可以选择合适的函数来使用。请注意，exec()函数族在执行成功后，会将当前进程替换为新的进程，因此之后的代码不会被执行到。

[22c974c5fb1e4ae8ab0d2094664de93e.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/bd04114a717b427499e57a1022f72041.gif
[5ae04542110a4e3ba3ee2675404ac4b5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/133f1dba4e264a49b5195db3d8abd7c4.png
[50c35a35310e483c9e19746d25f52f0a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/b773fe4a5546407a964bbd3cecf36202.png
[61a85e11651a4281b68a3dba4c58fac3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/d604b402679b49448494d3fdb7380b40.png
[c32c23ff3c78415ea7f19fbfeea3be84.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/8e7846ab09ce4c5db89fd5993ed0fc49.png
[6a34bdf7081645f3823f6415e39ba0ff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/17bffc69a48b4b9da21e124e22442aaa.png
[2d1b9e2a004f404d9c14136f8e0b212d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/a608d5d1c73044469c2fa3e998ab2dd2.png
[44b12de058b84d179b77742865a6a58c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/e357ba34c1a04971990c4ad825ee9e1f.png
[f5e1730a8f864724bd08282f1a3241fc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/68097fc432bd48dfb3bfb9f41b2c580d.png
[e62b25abd24244e7b45495dcdc005c44.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/9ea6bdec059e4b07b303e00b99029278.png
[6fff9dade215413690e912dfb9be3585.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/98b6e0fd97b24207b54d32cd39332baf.png
[815fae8ed1ce4900866f6c9b459f6573.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/fb84fa80e1b54790bdcefae117fc368d.png
[42ed61559e4d474fb9a68f7f76fdb709.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/72ea5355616f48d68f7f80fd4f384513.png