【Linux】进程控制3——进程程序替换

已于 2024-07-14 17:13:28 修改
阅读量1k 收藏 36
点赞数 37
分类专栏： Linux 文章标签： linux 服务器 运维
于 2024-06-13 19:21:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80224556/article/details/139650282
版权

1.什么是进程程序替换？

        在学习进程程序替换之前，我们知道当一个父进程创建一个子进程之后，父子进程的代码是共享的，子进程只能执行父进程的代码块

        但是现在我们的需求增加了，我们不仅要让子进程能够执行父进程的代码块，也要能够让子进程能够做一些父进程不能做的事情，也就是能够执行一个全新的代码（程序），这样就能实现父子进程做的事情有所差异，大大提高了办事效率，同时也使父子进程的代码彻底分离，维护进程的独立性

进程程序替换：子进程在运行时指向一个全新的程序代码

        所谓进程程序替换，顾名思义，就是使用一个新的程序替换原有的程序，进程将执行新程序的代码，而不再执行原有程序的代码，前面我们已经学习了如何创建一个进程，一般情况下，进程程序替换都不会使用父进程直接进行进程程序替换，而是让父进程调用fork()函数创建一个子进程，让子进程去执行一个新的程序即可

这个过程通常是由操作系统提供的 exec 系列函数来实现的：

  • exec 函数族：exec 函数族是一组系统调用，用于执行程序替换操作。这些函数包括 execl, execv, execle, execve 等，它们允许以不同的方式传递参数给新程序，并执行地址空间替换。（我们要改变内存，那肯定是要调用系统调用接口的，这些函数会封装相应的接口）

我们先看简单版本

参数说明：

  • path：要执行的程序的路径。
  • arg：新程序的参数列表的开始，通常这会是新程序的名称（尽管这不是强制的，但它通常用于错误消息和程序内部）。
  • ...：一个可变参数列表（参数的数量不固定），新程序的参数列表，必须以NULL结尾。

 1.1.单进程版本

我们先看一个单进程版的 

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

int main()
{
printf("Before:I am a process,pid:%d,ppid:%d\n",getpid(),getppid());

execl("/usr/bin/ls","ls","-a","-l" ,NULL);//标准写法，最后一个必须使用NULL结尾


printf("After:I am a process,pid:%d,ppid:%d\n",getpid(),getppid());
}

上面这个执行了ls -al 命令，我们可以来验证一下

我们还发现，嗯？为什么After不见了？ 我们先不谈

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

int main()
{
printf("Before:I am a process,pid:%d,ppid:%d\n",getpid(),getppid());

execl("/usr/bin/top","top" ,NULL);//标准写法，最后一个必须使用NULL结尾


printf("After:I am a process,pid:%d,ppid:%d\n",getpid(),getppid());
}

执行了之后直接进入top的界面

好了，上面这样子的就叫程序替换，我们发现替换之后的那段程序不跑啊 

我们现在来研究一下这个过程啊

注意这里是单进程

        首先在替换函数执行之前啊，进程加载好自己的PCB，mm_struct，页表了，但是当执行到替换程序的时候，进程将ls这个命令的代码和数据加载到内存里，替换了原来这个进程的代码和数据。这个时候后面的After就从进程中消失了

1.2.多进程版本

我们看看多进程版本的进程替换 

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

int main()
{
	pid_t id = fork();
	if (id == 0)//子进程
	{
		printf("Before:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());

		sleep(5);
		execl("/usr/bin/ls", "ls","-l", NULL);//标准写法，最后一个必须使用NULL结尾

		printf("After:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());
        exit(1);//替换失败的时候，退出码是1
	}

	pid_t ret = waitpid(id, NULL, 0);
	if (ret > 0)  
		printf("wait success,father pid:%d,ret pid:%d\n", getpid(),ret);//ret是子进程的PID

	sleep(5);
}

 监视情况

现在我的问题是子进程执行excel会影响父进程吗？

 答案是不会，因为子进程调用excel时加载外部可执行文件的数据和代码时，发生了写时拷贝，不影响父进程，只影响子进程excel后面的代码

我们来了解一下

  •  进程替换前的效果图

当一个进程成功创建一个子进程之后，父子进程的情况如下图所示：

        这个时候，我们这里先针对代码和数据进行分析，其他内容暂不做考虑，此时父子进程都没有修改代码和数据，因此，父子进程的代码和数据都是指向同一块内容的，也就是代码和数据是共享的，如果其中一方对数据进行修改，则这一方就会进行写时拷贝，如果想要执行不同的代码，则此时就要进行进程程序替换

  •  进程替换之后的效果图

进程程序替换的原理：
        假如刚开始父子进程都是执行a.exe的代码，后面，想要让子进程执行b.exe了，那么此时就要进行进程程序替换，替换的过程就是首先将b.exe从磁盘加载进内存，拿b.exe的代码和数据替换子进程的代码和数据，然后更新子进程的页表中的映射关系（注意，这里修改的是页表中的物理地址而不是虚拟地址，此时父子进程代码块中虚拟地址是一样的，但是通过页表映射出来的物理地址是不一样的），从而实现父子进程的代码彻底分离，此时父子进程的代码是互不干扰的，很好地满足了进程的独立性 

1.3.进程替换的几个问题

1.程序替换有没有创建新进程？

        进程替换不会创建新进程，因为进程替换只是将该进程的数据替换为指定的可执行程序。而进程PCB没有改变，所以不是新的进程，进程替换后不会发生进程pid改变。

从哪里看出来呢？

从上面我们多进程版本例子中发现子进程的PID一直没有变化

我们父进程等待时获得的pid和子进程本来的PID一模一样，就说明没有额外创建进程 

进程替换就是用新的可执行程序的代码和数据取代掉 子进程的代码和数据（通过写实拷贝来实现），子进程的PCB，mm_struct，页表等数据结构都是原来那些（页表会更新物理内存的位置）

2.为什么子进程的打印After……没有执行？

 进程替换后，如果替换成功后则替换函数下的代码不会执行，因为进程替换是覆盖式的替换，替换成功后进程原来的代码就消失了。同理在进程替换失败后会执行替换函数后的代码

3.我上面没有接受execl的返回值，那我怎么知道他失败了？

我们得知道，进程替换函数在进程替换成功后不返回，函数的返回值表示替换失败 

 很简单啊，替换失败了才会执行excel后面的代码，那么我就让excel后面的代码来做点事来告诉我们这个进程替换失败了，就像下面这样

4.进程替换成功后，子进程退出码是谁的？

进程替换成功后，退出码为替换后的进程的退出码

5.我们的CPU如何得知程序的入口在哪里

Linux中形成的可执行程序是有自己的格式的，ELF，可执行程序的表头。——表头里有可执行程序的入口 ，我们进程替换换了一个可执行文件，这个可执行文件也有表头，就能被cpu读取，也就能执行了

2.程序替换接口——exec族函数

3号手册里面有下面6种接口

2号手册下面只有一个

我们来讲5个就够了

2.1.execl函数

      execl函数是Linux系统中用于执行新程序的函数之一，它属于exec函数族的一部分。

        这个函数的作用是在当前进程的上下文中启动一个新的程序，并替换当前进程的映像为新的程序映像。调用execl函数后，当前进程将停止执行，并由新的程序开始执行.

函数原型如下

参数说明：

  • path：要执行的程序的路径。
  • arg：新程序的参数列表的开始，通常这会是新程序的名称（尽管这不是强制的，但它通常用于错误消息和程序内部）。
  • ...：一个可变参数列表（参数的数量不固定），新程序的参数列表，必须以NULL结尾。

        execl函数会根据提供的路径path找到并执行相应的程序，同时将arg0及其后面的参数作为新程序的命令行参数传递。注意，参数列表必须以NULL结尾，这是告诉execl参数列表结束的标志。 

我们可以把它看成exec+l，后面这个l我们可以看作是list，因为list和它的用法特别相关

我们在传参的时候，从第二个参数开始，我们是一个一个传进去的，结尾是NULL，这特别像链表

第一个参数是可执行文件存储的位置，如上

参数为什么是"ls" "-l"呢？

因为我们命令行里面的用法就是ls -l，他们是等效的

所以我们想使用ls -l的时候，就传"ls","-l"，是不是特别简单？

命令行怎么写你就怎么传

例子看开头，我现在不想再讲了

但是有些东西我还是要强调

2.2.execlp

 这个函数比exec多了一个lp，l是list的意思，那p呢？

  • p是PATH的意思

        该函数与 execl 类似，但是它自己会在系统的环境变量 PATH 指定的目录中查找可执行文件。它的原型如下：

int execlp(const char *file, const char *arg0, ... /*, (char *)0 */);

        file 是要执行的可执行文件的文件名，arg0 是第一个参数，后续参数都是传递给可执行文件的命令行参数，以 NULL 结尾。

        相比于execl函数，execlp函数的第一个参数能直接写文件名，系统会PATH环境变量里去查找

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<sys/types.h>
int main()
{
	pid_t id = fork();
	if (id == 0)//子进程
	{
		printf("Before:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());

		sleep(5);
		execlp("/usr/bin/ls", "ls", "-l", NULL);//可以带路径，也可以不带，标准写法，最后一个必须使用NULL结尾

		printf("After:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());
		exit(1);//替换失败的时候，退出码是1
	}

	pid_t ret = waitpid(id, NULL, 0);
	if (ret > 0)
		printf("wait success,father pid:%d,ret pid:%d\n", getpid(), ret);//ret是子进程的PID

	sleep(5);
}

 这个环境变量PATH里有ls的路径，而环境变量本来是bash进程的，但是环境变量具有全局属性，子进程会继承父进程的环境变量 

2.3.execv：

  • execv多出来的v是vector的意思，可以理解为数组

类似于 execl，但是允许传递一个参数数组给被执行的程序。它的原型如下：

int execv(const char *path, char *const argv[]);
  • path 是要执行的可执行文件的路径，
  • argv 是一个以 NULL 结尾的参数数组，其中每个元素都是一个字符串，表示命令行参数。

 来看看用法吧

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<sys/types.h>
int main()
{
	pid_t id = fork();
	if (id == 0)//子进程
	{
		printf("Before:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());

		sleep(5);
		char* argv[] = { "ls","-a","-l",NULL};
		execv("/usr/bin/ls",argv);

		printf("After:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());
		exit(1);//替换失败的时候，退出码是1
	}

	pid_t ret = waitpid(id, NULL, 0);
	if (ret > 0)
		printf("wait success,father pid:%d,ret pid:%d\n", getpid(), ret);//ret是子进程的PID

	sleep(5);
}

2.4.反思进程替换

 

我们来深入理解一下

        ls是一个可执行程序，是由main函数的，而main函数接受命令行参数，那命令行参数哪里来？就是我们这里的“ls""-l""NULL”传进去的

在Linux中，所有的进程都是bash的子进程，所有子进程的启动都是使用exec族函数来启动的 

于其说进程替换，不如说是进程加载

 程序替换的本质就是加载 （可以看成一个加载器），有替换就是替换，没有就是程序加载

        程序替换的本质是程序加载，因为在执行 exec 函数时，操作系统会加载新程序的可执行文件，并将其代码、数据和堆栈等部分加载到进程的地址空间中。这个过程涉及将新程序的内容从磁盘加载到内存中，为进程提供执行所需的资源。

        因此，虽然我们常说是“程序替换”，但实际上更准确地说是将新程序加载到内存中，替换掉原有的程序，以实现进程的功能切换和更新。

2.4.execvp：

  • p是PATH的意思，v是vector的意思

类似于 execv，但是它会在系统的环境变量 PATH 指定的目录中查找可执行文件。

它的原型如下：

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

file 是要执行的可执行文件的文件名，argv 是一个以 NULL 结尾的参数数组，其中每个元素都是一个字符串，表示命令行参数。

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<sys/types.h>
int main()
{
	pid_t id = fork();
	if (id == 0)//子进程
	{
		printf("Before:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());

		sleep(5);
		char* argv[] = { "ls","-a","-l",NULL};
		execvp("ls",argv);

		printf("After:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());
		exit(1);//替换失败的时候，退出码是1
	}

	pid_t ret = waitpid(id, NULL, 0);
	if (ret > 0)
		printf("wait success,father pid:%d,ret pid:%d\n", getpid(), ret);//ret是子进程的PID

	sleep(5);
}

 

2.5.调用其他语言的程序 

exec族函数能执行系统的命令，能执行我们的命令吗？ 

这个是完全没有问题的

我们下面用一个c语言的程序来调用一个c++程序

 

把它删了吧 

接下来我们修改一下我们的makefile，让它一次性生成两个可执行程序

编译之后我们发现只能形成一个mytest，问题在哪里？

makefile默认执行前面那个，发现前面那个执行完了就没有依赖关系了，直接结束了，所以不能让它们两个放在前面

我们改成下面这个即可

要形成all就必须要mytest和otherexe，所以两个都会形成了

事实上这个all是makefile里的伪目标，是不会生成的

怎么样呢?

好了我们现在要用一个程序去调用另外一个程序

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<sys/types.h>
int main()
{
	pid_t id = fork();
	if (id == 0)//子进程
	{
		printf("Before:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());

		sleep(5);
		execl("./otherexe", "otherexe", NULL);

		printf("After:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());
		exit(1);//替换失败的时候，退出码是1
	}

	pid_t ret = waitpid(id, NULL, 0);
	if (ret > 0)
		printf("wait success,father pid:%d,ret pid:%d\n", getpid(), ret);//ret是子进程的PID

	sleep(5);
}

 

怎么样呢？

现在你肯定有个问题，明明我们调用otherexe的时候在命令行里是输入./otherexe，那为什么我们传参传的是otherexe而不是./otherexe？

其实你传 otherexe和./otherexe都行，都能运行

除此之外，我们可调用不同编程语言的可执行程序！！

我们下面再介绍一个

c语言调用脚本语言程序

有点神奇 

来吧，用c语言调用一下这个脚本语言的程序

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<sys/types.h>
int main()
{
	pid_t id = fork();
	if (id == 0)//子进程
	{
		printf("Before:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());

		sleep(5);
		execl("/usr/bin/bash", "bash","test.sh", NULL);

		printf("After:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());
		exit(1);//替换失败的时候，退出码是1
	}

	pid_t ret = waitpid(id, NULL, 0);
	if (ret > 0)
		printf("wait success,father pid:%d,ret pid:%d\n", getpid(), ret);//ret是子进程的PID

	sleep(5);
}

 

太简单了 

至于其他语言的程序，照样运行，不讲了，简单，太简单啦

为什么能跨语言调用？

所有的语言运行起来都是进程，所以就能调用！！！！就能拿c/c++调用 

2.5.命令行参数，环境变量

首先我们要知道环境变量具有全局性，进程程序替换是不会替换环境变量的

想要子进程继承全部的环境变量，不用管，直接就能拿到

说到环境变量，不急，我们先验证一下命令行参数能不能传递 

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

int main()
{
	pid_t id = fork();
	if (id == 0)//子进程
	{
		printf("Before:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());

		sleep(5);
		const char* myargv[] = {
			"otherexe","-a","-b","-c",NULL
		};
		execv("./otherexe", myargv);

		printf("After:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());
		exit(1);//替换失败的时候，退出码是1
	}

	pid_t ret = waitpid(id, NULL, 0);
	if (ret > 0)
		printf("wait success,father pid:%d,ret pid:%d\n", getpid(), ret);//ret是子进程的PID

	sleep(5);
}

 

我们就此验证命令行参数是可以传进去的

我们接下来验证环境变量

 

 

……

环境变量自动被子进程拿到了

1.我压根没有传环境变量啊？？它怎么知道我的环境变量？ 环境变量是上面时候给进程的？ 

环境变量也是数据！！！！！！ 创建子进程的时候子进程就从父进程那里拿到环境变量了

2.我们程序替换不是换了子进程的代码和数据吗？ 

环境变量不会被替换啊！！！！ 

3.我如果想给子进程传递环境变量应该怎么办？

  • 1.新增环境变量
  • 2.删除之前的环境变量 

我们得知道环境变量会从bash一路继承下来

4.我们怎么传递环境变量

单纯新增环境变量，在父进程里使用putenv()函数，会影响子进程

putenv 是 C 语言中的一个库函数，它定义在 <stdlib.h> 头文件中。这个函数用于将字符串添加到环境变量中，或者修改已经存在的环境变量的值。

int putenv(const char *string);

使用全新的环境变量，就使用execle()函数，那么替换后的代码切换后的环境变量就只是我们传入的表里的内容

我们来看一个例子

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

int main()
{
	putenv("PRIVATE_ENV=6666666");
	pid_t id = fork();
	if (id == 0)//子进程
	{
		printf("Before:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());

		sleep(5);
		const char* myargv[] = {
			"otherexe","-a","-b","-c",NULL
		};
		execv("./otherexe", myargv);

		printf("After:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());
		exit(1);//替换失败的时候，退出码是1
	}

	pid_t ret = waitpid(id, NULL, 0);
	if (ret > 0)
		printf("wait success,father pid:%d,ret pid:%d\n", getpid(), ret);//ret是子进程的PID

	sleep(5);
}

 

看到第25号了吗？就是我刚加上去的

我们看看bash里有没有

一点关系也没有

这好像继承啊，最顶上的很少，后面越来越多

5.强行传环境变量 

2.5.1.execle：

  • 多出来的e是enviroment的意思，l是list的意思

函数与 execl 函数类似，但允许在启动新程序时传递额外的环境变量。

它的原型如下：

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

path 是要执行的可执行文件的路径，arg 是要传递给新程序的命令行参数，后面的参数是额外的环境变量，以 NULL 结尾。

 我们先用这个函数来传递一下系统的环境变量

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

int main()
{
	extern char** environ;
	putenv("PRIVATE_ENV=6666666");//创建环境变量
	pid_t id = fork();
	if (id == 0)//子进程
	{
		printf("Before:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());

		sleep(5);
		const char* myargv[] = {
			"otherexe","-a","-b","-c",NULL
		};
		execle("./otherexe","otherexe","-a","-w","-v",NULL,environ );

		printf("After:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());
		exit(1);//替换失败的时候，退出码是1
	}

	pid_t ret = waitpid(id, NULL, 0);
	if (ret > 0)
		printf("wait success,father pid:%d,ret pid:%d\n", getpid(), ret);//ret是子进程的PID

	sleep(5);
}

 

 

怎么样呢？

我们能不能自定义环境变量？ 

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

int main()
{

	pid_t id = fork();
	if (id == 0)//子进程
	{
		printf("Before:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());

		sleep(5);
		
		const char* myenv[] = {//自定义环境变量
			"MY_VALUE1=1111",
			"MY_VALUE2=2222",NULL
		};
		execle("./otherexe","otherexe","-a","-w","-v",NULL,myenv );

		printf("After:I am a process,pid:%d,ppid:%d\n", getpid(), getppid());
		exit(1);//替换失败的时候，退出码是1
	}

	pid_t ret = waitpid(id, NULL, 0);
	if (ret > 0)
		printf("wait success,father pid:%d,ret pid:%d\n", getpid(), ret);//ret是子进程的PID

	sleep(5);
}

 

我靠，系统的环境变量没了，只剩自己的了！！！！

注意：

  • 1.导环境变量的数组最后以NULL结尾
  • 2.导入自定义环境变量后原系统环境变量的值被清空，这种导入环境变量的方式为覆盖式导入 

3.总结

1，程序替换一旦成功，exec后面的代码不在执行。因为被替换掉了，这也是什么代码没有输出execl end的原因了

2，exec函数调用成功，那么它实际上不会有返回值；调用失败，它会返回-1

3，exec函数不会创建新的进程。它们只是在当前进程的上下文中启动另一个程序

4，创建一个进程。我们是先创建PCB、地址空间、页表等再先把程序加载到内存

                                如果先加载的话，页表都没办法映射的

5，程序替换的本质就是加载 （可以看成一个加载器），有替换就是替换，没有就是程序加载

        程序替换的本质是程序加载，因为在执行 exec 函数时，操作系统会加载新程序的可执行文件，并将其代码、数据和堆栈等部分加载到进程的地址空间中。这个过程涉及将新程序的内容从磁盘加载到内存中，为进程提供执行所需的资源。

        因此，虽然我们常说是“程序替换”，但实际上更准确地说是将新程序加载到内存中，替换掉原有的程序，以实现进程的功能切换和更新。

6，程序运行要加载到内存；为什么？

        冯诺依曼体系规定；

如何加载的呢？

        就是程序替换：程序替换是操作系统的接口，所谓的把磁盘里的数据加载到内存就是把磁盘设备的数据拷贝到内存里。把数据从一个硬件搬到另一个硬件，只有操作系统能做

掘根
关注
  • 37
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 12
    评论
专栏目录
【Linux】进程控制——程序替换
风铃的博客
02-21 654
文章目录✅1.复习✅2.学习程序替换2.1.替换原理2.2.替换函数2.3.函数解释2.4.命名理解2.5.如何替换2.6.exec举例2.7.图解✅3.练习题第一题(多选）第二题（单选）第三题（多选） ✅1.复习 每日一问，今天也要好好复习????‍♀️ 进程控制——深刻理解进程创建 进程控制——进程终止的三种方法 进程控制——进程等待 进程等待2.0，如何获取子进程的status ✅2.学习程序替换 2.1.替换原理 用fork创建子进程后执行的是和父进程相同的程序，但是有可能执行不同的代码分
Linux进程控制详解及实例
09-15
Linux进程控制是操作系统的核心组成部分，它允许用户和系统创建、管理以及终止进程。在这个主题中，我们将深入探讨几个关键的Linux进程控制函数，包括fork()、exec家族、wait()和exit()，并提供实例来解释它们如何...
Linux 进程控制补充 —— 进程程序替换
原来45的博客
10-20 501
我们现在知道，fork出来的子进程是执行父进程的代码片段，但是如果我们想要创建出来的子进程，执行其他的程序呢？这就需要进程的程序替换了。
Linux进程控制——Linux进程程序替换
EterNity_TiMe_的计算机学习之路
05-15 1413
进程替换进程程序替换能够让我们只用C语言就可以调用其他任何语言去执行，极大程度上带来了便利，也可以帮助我们完成很多任务，让我们一探究竟！
【Linux】进程控制 —— 进程替换
Hello_World_213的博客
09-25 1252
[Linux]进程替换原理, exec系列系统调用, 用C程序执行其他语言程序, 模拟实现简单的shell(命令行解释器)
Linux——详解进程控制之替换
weixin_61857742的博客
09-29 851
与之前execl、execv相同，环境变量传链式结构或指针数组。filename传入文件绝对/相对路径+文件名。*envp[]传入带有环境变量的指针数组。当然最后应以NULL结尾。当创建失败时，函数会返回-1并在errno中记录该错误原因。errno是一个系统参数，由操作系统直接维护，会记录最新的错误。除此之外，execl、execv、execlp、execvp、execle都是在第三手册中，只有execve在第二手册中。
Linux操作系统——进程控制（三） 进程程序替换
希望自己从编程小白变成大佬
01-11 837
其实我们前面就说过，父进程创建子进程之后，代码和数据是共享的，如果父子进程中有一个进程需要修改数据的话那么会发生写时拷贝，那么我们上面又说程序替换是将进程的代码和数据进行替换的，那么一旦替换父子进程的代码和数据都会被替换，但是我们这里仅仅只是子进程发生程序替换，父进程不需要发生程序替换，所以这种情况不存在。因为当我们进行程序替换时，我们并没有增加或减少或改变进程的pid，进程的pcb并没有发生改变，发生改变的只是进程PCB中通过进程地址空间通过页表映射到对应物理内存的代码和数据。我们发现程序替换成功了。
Linux进程控制——Linux进程终止
EterNity_TiMe_的计算机学习之路
05-12 1860
进程终止相对于其他的进程控制来说，是很好理解的。我们主要介绍了进程终止，在明白错误码和退出码之后，相信能理解父进程是怎么得到子进程信息的。让我们期待下一节——进程等待与替换！
Linux——进程控制
Tlzns的博客
04-27 1039
Linux——进程控制
【Linux篇】第八篇——Linux下的进程控制（进程创建+进程终止+进程等待+进程程序替换+简易shell的实现）
weixin_58450087的博客
03-20 2768
⭐️这篇博客就要开始聊一聊进程控制相关的内容了，这部分的内容十分的丰富且十分的重要，序号这一块内容是非常有必要的 目录进程创建fork函数写时拷贝进程终止进程退出的三种场景进程常见的退出方法进程等待进程等待的方法 进程创建 fork函数 fork这个函数我在第一次讲进程创建的那篇博客中介绍过了，关于fork的返回值和用法可以去看右边这篇博客，这里就简单说明一下。（Linux进程） fork函数也是一个系统调用接口，为当前进程创建子进程，子进程返回0，父进程返回子进程的pid，出错返回-1 进程调.
Linux下C语言编——进程
07-24
子进程可以通过`exec()`系列函数（如`execl()`, `execv()`, `execle()`, `execvp()`等）替换其内存中的代码，从而运行新的程序。 另一个重要的进程类型是守护进程（daemon）。守护进程通常在后台运行，不与终端关联...
Linux进程-zhangwl.rar_linux_linux 进程_linux进程_源码分析_进程 linux
09-22
这个调用会复制当前进程的所有状态，包括内存映射、打开的文件描述符、环境变量等，形成一个全新的进程——子进程。子进程与父进程共享相同的代码段，但拥有独立的数据段和堆栈，可以进行独立的执行路径。 接着，是...
Linux中使用C语言的fork()函数创建子进程的实例教程
09-02
在更复杂的场景中，`fork()`可以结合其他系统调用，如`exec()`系列（如`execl()`, `execv()`, `execle()`, `execlp()`, 和 `execvp()`），用于在子进程中替换当前的执行上下文，运行新的程序。此外，`wait()`和`...
tongbu.zip_linux 多进程_linux 进程_多进程Linux_进程同步
09-19
在Linux操作系统中，多进程是程序执行的一种方式，它允许同时执行多个独立的程序实例，每个实例称为一个进程。在“tongbu.zip_linux 多进程_linux 进程_多进程Linux_进程同步”这个资源中，我们主要探讨的是如何在...
建立共享linux第三方软件仓库
Znj1421304181的博客
07-08 226
【代码】建立共享linux第三方软件仓库。
【Linux系列2】Cmake安装记录
kewaqi618的博客
07-08 1045
主要介绍Cmake的安装方法，及自己安装的过程
linux，docker，k8s常见命令
buaixuexideshuge的博客
07-07 932
命令
Linux —— 进程间通信
最新发布
学习C++的小陈同学
07-11 956
本篇整理了关于进程间通信的内容，以及详解的介绍了两种进程间通信的方式，以及相关的接口和代码演练
实验六 进程控制1
08-08
1. 进程与程序由于一个进程对应一个程序的执行，但进程不等同于程序 2. Linux环境下的进程管理Linux环境下的进程管理包括启动进程和调度进程 2. sy

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值