【Linux】环境变量、进程替换、wait/waitpid

最新推荐文章于 2024-07-11 10:51:42 发布
最新推荐文章于 2024-07-11 10:51:42 发布
阅读量1k 收藏 26
点赞数 13
分类专栏： Linux 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62714628/article/details/138390034
版权

文章目录

一、环境变量

1. 查看环境变量的方法

1.1 env

可以查看当前进程的所有环境变量.
在这里插入图片描述

1.2 echo $环境变量名

可以查看指定的环境变量.
在这里插入图片描述

2. 在代码中使用环境变量的方法

2.1 命令行参数传参

通过设置 main 函数的第三个形参 char* envp[ ], 接收环境变量.

#include <iostream>
using namespace std;

int main(int argc, char* argv[], char* envp[])
{
	for (int i = 0; envp[i]; ++i)
	{	
		cout << envp[i] << endl;
	}   
	return 0;
}

程序运行起来会是 bash 的子进程, 子进程会继承父进程的环境变量, envp 的最后一个位置会存储一个 NULL, 所以可以用作循环条件的判断.

2.2 environ变量

通过 extern 关键字引用外部变量, extern char** environ.

#include <iostream>
using namespace std;

extern char** environ;

int main()
{
	for (int i = 0; environ[i]; ++i)
	{	
		cout << environ[i] << endl;
	}   
	return 0;
}

environ 不包含在任何头文件中, 所以要使用 extern 引入.

2.3 getenv( )函数

通过 getenv( ) 可以获取指定的环境变量, 传递的参数是环境变量名.
头文件: #include <stdlib.h>
函数声明: char *getenv(const char *name);

#include <iostream>
#include <stdlib.h>
using namespace std;

int main()
{
	cout << getenv("USER") << endl;
	cout << getenv("HOME") << endl;
	return 0;
}

运行结果:
在这里插入图片描述

3. export

在 Linux 中, 像 ls, pwd 这样的指令可以直接敲了就运行, 而我们编写的代码在生成了可执行文件后要通过 ./xxx 的方式才可以运行, 这是为什么呢? 本质都是一个程序, 跑起来变成进程, 原因是 ls, pwd 这种指令的路径添加到了环境变量 PATH 中, 所以在运行时系统在环境变量 PATH 中可以找到, 而我们自己编写的程序的路径不存在环境变量 PATH 中, 所以要指定路径.

自己编写的程序, 如果不加 ./ 直接跑起来是这样的:
在这里插入图片描述

那么试着把自己编写的程序的所在路径添加到环境变量 PATH 中, 看看可不可以不需要 ./ 直接跑起来, 通过 export 添加到环境变量:

export PATH=$PATH:/root/EnvTest/Test/

$PATH 表示之前添加到 PATH 中的所有路径, 将自己编写的程序的所在路径写在冒号右边就好, 不要直接写成 PATH=/root/EnvTest/Test/, 这样写会把之前的路径都覆盖掉, 属于覆盖式写入.

运行结果:
在这里插入图片描述
可以看到可以不带 ./ 直接运行了, 再看看 PATH 中也存在了刚才添加的路径:
在这里插入图片描述

二、进程替换

用 fork 创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支), 子进程往往要调用一种 exec 函数以执行另一个程序。当进程调用一种exec函数时, 该进程的代码和数据完全被新程序替换, 从新程序的启动例程开始执行. 调用exec并不创建新进程,所以调用exec 前后该进程的 pid 不会改变.

下面介绍各种 exec 函数, 头文件均为: #include <unistd.h>

1. execl

函数声明: int execl(const char *path, const char *arg, …);

  • path: 替换程序的路径
  • arg/…: 可变参数列表
#include <iostream>
#include <unistd.h>
using namespace std;

int main()
{
	cout << "111" << endl;
	cout << "222" << endl;
	cout << "333" << endl;
	
	execl("/usr/bin/ls", "ls", "-l", "-a", NULL);
	
	cout << "444" << endl;
	cout << "555" << endl;
	cout << "666" << endl;
	return 0;
}

假设要替换的进程为 ls, 那么就把 ls 的路径写在 path 处, 在可变参数列表分别加上在终端如何执行 ls 的指令, 每个选项单独写, 最后必须以 NULL 结尾.

运行结果:
在这里插入图片描述
可以看到前面三行代码正常输出, 进程替换后的代码不会输出, 因为在函数调用处后的代码会被替换.

2. execlp

函数声明: int execlp(const char *file, const char *arg, …);

  • file: 替换程序名
  • arg/…: 可变参数列表
#include <iostream>
#include <unistd.h>
using namespace std;

int main()
{
	cout << "111" << endl;
	cout << "222" << endl;
	cout << "333" << endl;
	
	execl("ls", "ls", "-l", "-a", NULL);
	
	cout << "444" << endl;
	cout << "555" << endl;
	cout << "666" << endl;
	return 0;
}

path 处不需要指明路径了, 直接写上替换程序的名称即可, 后面的可变参数列表处和 execl 一致.

运行结果:
在这里插入图片描述
需要注意的是, 如果替换的程序是你自己编写的, 那么需要把它所在的路径添加到 PATH 中, 否则不会替换.

3. execle

函数声明: int execle(const char *path, const char *arg, …, char * const envp[ ]);

  • path: 替换程序的路径
  • arg/…: 可变参数列表
  • envp: 环境变量列表

程序 myenv, 执行起来就是查看该进程的环境变量:
在这里插入图片描述
execle 示例代码:

#include <iostream>
#include <unistd.h>
using namespace std;

int main()
{
	cout << "111" << endl;
	cout << "222" << endl;
	cout << "333" << endl;
	
	char*const envp[] = {"MYENV=100", NULL};
	execle("/root/ExecTest/myenv", "myenv", NULL, envp);
	
	cout << "444" << endl;
	cout << "555" << endl;
	cout << "666" << endl;
	return 0;
}

传递环境变量需要自定义一个数组进行传递, 在数组中依然要以 NULL 结尾, 但是此时来看一看运行结果:
在这里插入图片描述
确实是把传递的环境变量给输出出来了, 但是之前的环境变量被覆盖了, 没错 execle 传递环境变量就是覆盖式传入, 那么如何做到不覆盖进程原本的环境变量, 又把新的环境变量传入呢? 先看一个函数 putenv( ):

头文件: #include <stdlib.h>
函数声明: int putenv(char *string);

该函数的功能很简单, 就是哪个进程调用该函数, 就把传递的环境变量形参设置到哪个进程的环境变量中.

结合该函数就可以实现不覆盖进程原本的环境变量, 又把新的环境变量传入, 如下:

#include <iostream>
#include <unistd.h>
#include <stdlib.h>
using namespace std;

extern char** environ;

int main()
{
	cout << "111" << endl;
	cout << "222" << endl;
	cout << "333" << endl;
	
	putenv("MYENV=100");
	execle("/root/ExecTest/myenv", "myenv", NULL, environ);
	
	cout << "444" << endl;
	cout << "555" << endl;
	cout << "666" << endl;
	return 0;
}

其实也很简单, 就是先把新的环境变量导入当前进程, 再把 environ 当作形参传递就好了.

运行结果:
在这里插入图片描述
可以看到, 不仅输出了原本的环境变量, 而且新添加的也输出了, 那么就成功做到了不覆盖进程原本的环境变量, 又把新的环境变量传入.

4. execv

函数声明: int execv(const char *path, char *const argv[]);

  • path: 替换程序的路径
  • argv: 执行该程序的指令数组
#include <iostream>
#include <unistd.h>
using namespace std;

int main()
{
	cout << "111" << endl;
	cout << "222" << endl;
	cout << "333" << endl;
	
	char*const argv[] = {"ls", "-l", "-a", NULL};
	execv("/usr/bin/ls", argv);
	
	cout << "444" << endl;
	cout << "555" << endl;
	cout << "666" << endl;
	return 0;
}

其实很简单, 和 execl 没什么区别, 无非是把替换程序的执行指令写在一个数组中, 再把数组作为参数传给 execv, 注意数组最后必须以 NULL 结尾即可.

运行结果:
在这里插入图片描述

5. execvp

函数声明: int execvp(const char *file, char *const argv[]);

  • file: 替换程序名
  • argv: 执行该程序的指令数组
#include <iostream>
#include <unistd.h>
using namespace std;

extern char** environ;

int main()
{
	cout << "111" << endl;
	cout << "222" << endl;
	cout << "333" << endl;
	
	char*const argv[] = {"ls", "-l", "-a", NULL};
	execv("ls", argv);
	
	cout << "444" << endl;
	cout << "555" << endl;
	cout << "666" << endl;
	return 0;
}

和 execv 差不多, 无非是函数的第一个参数直接传可执行程序名即可.

运行结果:
在这里插入图片描述

6. execvpe

函数声明: int execvpe(const char *file, char *const argv[], char *const envp[]);

  • file: 替换程序名
  • argv: 执行该程序的指令数组
  • envp: 环境变量列表
#include <iostream>
#include <unistd.h>
#include <stdlib.h>
using namespace std;

extern char** environ;

int main()
{
	cout << "111" << endl;
	cout << "222" << endl;
	cout << "333" << endl;
	
	putenv("MYENV=100");
	char*const argv[] = {"myenv", NULL}; 
	execvpe("myenv", argv, environ);

	cout << "444" << endl;
	cout << "555" << endl;
	cout << "666" << endl;
	return 0;
}

无非就是第一个参数直接传递替换程序名, 第二个参数传递执行该程序的指令数组, 第三个参数传递环境变量数组, 和之前的大同小异
运行结果:
在这里插入图片描述

7. 补充

7.1 命名理解

exec 函数名中的规律:

  • 带 l 的: l = list, 表示传参直接传在函数参数列表中.
  • 带 v 的: v = vector, 表示一部分参数可以先写在数组中, 再把数组当作参数传递.
  • 带 p 的: p = path, 表示不需要传路径, 直接传递替换程序名即可.
  • 带 e 的: e = env, 表示自己维护环境变量.

7.2 返回值

exec( ) 函数仅在发生错误时返回, 返回值为 -1，并设置 errno 以指示错误, 其实不需要关心返回值, 因为如果成功程序会被替换, 失败不会被替换, 剩于的代码也会执行, 无论成功与否都可以很直观的判断出函数执行的结果.

三、wait/waitpid

子进程在退出后会变成僵尸进程, 通过 wait/waitpid 可以再获取了子进程的退出状态后将身为僵尸进程的子进程释放, 如果长期不释放会导致内存泄漏.

头文件均为:
#include <sys/types.h>
#include <sys/wait.h>

1. wait

函数原型: pid_t wait(int *status);
参数: 输出型参数, 可以获取进程的退出状态, 不需要获取退出状态设置为NULL.
返回值:

  • 成功: 返回被等待的进程的 pid.
  • 失败: 返回 -1, 这时errno会被设置成相应的值以指示错误所在.

示例代码:

#include <iostream>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
using namespace std;

int main()
{
	pid_t ret1 = fork(); //以此往后分化为两个进程执行
	//子进程
	if (ret1 == 0)
	{
		for (int i = 0; i < 5; ++i)
		{
			cout << "I am child, my pid:" << getpid() << endl;
			sleep(1);
		}
	}
	else
	{
		pid_t ret2 = wait(NULL);
		cout << "wait success, ret2:" << ret2 << endl;
	}
	return 0;
}

子进程调用 5 次 cout << “I am child, my pid:” << getpid() << endl; 输出信息, 最后由父进程成功 wait 并且输出 wait 的返回值.

运行结果:
在这里插入图片描述
通过图片无法看出, 但是以上代码是两个进程再跑, 但是情况是这样的, 父进程一直 wait 子进程退出, 而这种等待是阻塞式等待, 所以其结论就是父进程在使用 wait 时是处于阻塞式等待的, 需要子进程退出后并且父进程 wait 结束后才会往下执行父进程剩于的代码.

2. waitpid

函数原型: pid_t waitpid(pid_t pid, int *status, int options);
参数:

  • pid: 设置为 -1 表示等待任一子进程, 设置为 >0 表示等待指定 pid 的子进程.
  • status: 输出型参数, 可以获取进程的退出状态, 不需要获取退出状态设置为NULL.
  • options: 设置为 0 表示阻塞式等待, 设置为 WNOHANG 表示非阻塞式等待.

返回值:

  • 正常返回时, 返回等待的子进程的 pid.
  • 如果 options 设置了选项WNOHANG, 而调用中 waitpid 发现没有已退出的子进程可等待, 则返回0.
  • 失败返回 -1, 这时errno会被设置成相应的值以指示错误所在.

示例代码:

#include <iostream>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
using namespace std;

int main()
{
	pid_t ret1 = fork(); //以此往后分化为两个进程执行
	//子进程
	if (ret1 == 0)
	{
		for (int i = 0; i < 5; ++i)
		{
			cout << "I am child, my pid:" << getpid() << endl;
			sleep(1);
		}
	}
	else
	{
		int status = 0;
		pid_t ret2 = 0;
		do
		{
			ret2 = waitpid(ret1, &status, WNOHANG);
			cout << "father is running." << endl;
			sleep(1);
		}while(ret2 == 0)
		cout << "waitpid success, ret2:" << ret2 << endl;
	}
	return 0;
}

运行结果:
在这里插入图片描述
可以看到在子进程没有退出时, 父进程还是有在往后执行的, 而且在子进程退出时, 父进程也能成功的等待到子进程.

3. 获取子进程的退出状态

在 wait/waitpid 中都有 status, status 是 int 类型, 那么共有 32 位, status 是当作一个位图使用, 在其中存储着退出状态信息, 如下图:
在这里插入图片描述
其中 status 的高 16 位不用, 只使用低 16 位, 而次低 8 位用于存储退出码, 就是 return, exit 携带的数字, 低 7 位存储终止信号, 如果终止信号为 0 表示正常退出, 接着可以获取其退出码, 判断结果是否正确, 如果终止信号不为 0, 表示进程是被信号所终止退出的, 此时为异常退出, 异常退出退出码没有意义, 所以未被设置, 直接获取终止信号判断分析异常退出原因即可.

3.1 位运算获取退出状态

获取退出码: ((status >> 8) & (0xff))
获取终止信号: (status & (0x7f))

退出码示例代码:

#include <iostream>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
using namespace std;

int main()
{
	pid_t ret1 = fork(); //以此往后分化为两个进程执行
	//子进程
	if (ret1 == 0)
	{
		for (int i = 0; i < 5; ++i)
		{
			cout << "I am child, my pid:" << getpid() << endl;
			sleep(1);
		}
	}
	else
	{
		int status = 0;
		pid_t ret2 = 0;
		do
		{
			ret2 = waitpid(ret1, &status, WNOHANG);
			cout << "father is running." << endl;
			sleep(1);
		}while(ret2 == 0)
		cout << "waitpid success, ret2:" << ret2 << ", exit code:" << ((status >> 8) & (0xff)) << ", signal:" << (status & (0x7f)) << endl;
	}
	return 0;
}

运行结果:
在这里插入图片描述
为了直观的看到退出码, 改变一下代码:

#include <iostream>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
using namespace std;

int main()
{
	pid_t ret1 = fork(); //以此往后分化为两个进程执行
	//子进程
	if (ret1 == 0)
	{
		for (int i = 0; i < 5; ++i)
		{
			cout << "I am child, my pid:" << getpid() << endl;
			sleep(1);
		}
		return 111; //为了更直观的看到退出码
	}
	else
	{
		int status = 0;
		pid_t ret2 = 0;
		do
		{
			ret2 = waitpid(ret1, &status, WNOHANG);
			cout << "father is running." << endl;
			sleep(1);
		}while(ret2 == 0)
		cout << "waitpid success, ret2:" << ret2 << ", exit code:" << ((status >> 8) & (0xff)) << ", signal:" << (status & (0x7f)) << endl;
	}
	return 0;
}

运行结果:
在这里插入图片描述

终止信号示例代码:

#include <iostream>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
using namespace std;

int main()
{
	pid_t ret1 = fork(); //以此往后分化为两个进程执行
	//子进程
	if (ret1 == 0)
	{
		for (int i = 0; i < 5; ++i)
		{
			cout << "I am child, my pid:" << getpid() << endl;
			sleep(1);
		}
		return 111; //为了更直观的看到退出码
	}
	else
	{
		int status = 0;
		pid_t ret2 = 0;
		do
		{
			ret2 = waitpid(ret1, &status, WNOHANG);
			cout << "father is running." << endl;
			sleep(1);
		}while(ret2 == 0)
		if((status & (0x7f)))
		{
			cout << "waitpid success, ret2:" << ret2 << ", signal:" << (status & (0x7f)) << endl;                                                                       
		} 
	}
	return 0;
}

如果终止信号不为 0, 表示异常退出, 此时就没必要获取退出码了, 因为此时的退出码不具有参考性, 没有获取的必要.

发送 9 号信号 kill 掉进程:

kill -9 20266

运行结果:
在这里插入图片描述

3.2 内置宏获取退出状态

WIFEXITED(status): 若为正常终止子进程返回的状态, 则为真.（查看进程是否是正常退出）
WEXITSTATUS(status): 若WIFEXITED非零, 提取子进程退出码.（查看进程的退出码）

示例代码:

#include <iostream>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
using namespace std;

int main()
{
	pid_t ret1 = fork(); //以此往后分化为两个进程执行
	//子进程
	if (ret1 == 0)
	{
		for (int i = 0; i < 5; ++i)
		{
			cout << "I am child, my pid:" << getpid() << endl;
			sleep(1);
		}
		return 111; //为了更直观的看到退出码
	}
	else
	{
		int status = 0;
		pid_t ret2 = 0;
		do
		{
			ret2 = waitpid(ret1, &status, WNOHANG);
			cout << "father is running." << endl;
			sleep(1);
		}while(ret2 == 0)
		//正常退出,查看退出码
		if(WIFEXITED(status))
		{
			cout << "waitpid success, ret2:" << ret2 << ", exit code:" << WEXITSTATUS(status) << endl;
		}
		else
		{
			cout << "waitpid success, ret2:" << ret2 << ", signal:" << (status & (0x7f)) << endl;
		}
	}
	return 0;
}

因为没有提供查看终止信号的宏, 所以查看终止信号仍需要用位运算的方法.

运行结果:
在这里插入图片描述

d4uu
关注
  • 13
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
009exec函数wait、waitpid回收子进程
m0_73604721的博客
11-16 433
Linux系统编程学习笔记
linux多进程.rar
04-05
本资料"linux多进程.rar"包含的易语言源码，显然是为了教学或实践如何在Linux环境下创建和管理多进程。 在Linux系统中，进程是系统资源分配的基本单位，每个进程都有自己的独立内存空间，它们之间通过特定的方式...
Linux进程控制：fork、exec、wait/waitpid
weixin_44498318的博客
04-18 2174
fork函数 fork函数比较特殊，“调用一次返回两次”，调用它可以创建出一个子进程。可以看下例子： #include <unistd.h> #include <stdio.h> #include <stdlib.h> int main(void) { pid_t pid; char *message; int n; pid = fork(); if...
Linux之进程的创建与回收（fork，wait/waitpid exec函数家族）
qq_66157971的博客
10-11 183
产后这个问题的原因是我们没有设置阻塞，父进程不会阻塞等待子进程，这个逻辑只会执行一次，子进程很可能没有被回收，因此要想子进被回收就需要一个循环反复执行这个逻辑，直到wpid的值为-1即表示所有的进程被全部回收，方可退出。既然有父进程先执行完就一定有子进程先执行完的情况，子进程先执行完，父进程没有完成对子进程的回收，因此子进程就成为了一个僵尸进程，注意僵尸进程是一个已经执行完的进程，不能再使用kill命令将其杀死，但是可以通过kill命令杀死它的父进程，让这个子进程被init进程领养，最后完成子进程的回收。
进程 fork exec，wait/waitpid
ZC20141220的博客
08-11 435
1,函数原型为：pid_t fork();调用一次返回两次，返回调用进程的pid号。      pid_t pid;      pid=fork();      如果pid>0，则是子进程的进程号，说明此时调用进程是父进程；如果返回是0，则说明此时调用进程是子进程，若            因为读时共享和写时复制，子进程会复制父进程的代码，但是从fork下开始执行。但是，当在fork前定
Linux编程.zip_Linux/Unix编程_C/C++__Linux/Unix编程_C/C++_
08-09
9. **进程间通信（IPC）**：虽然简单shell可能不涉及复杂的IPC，但理解`waitpid()`和`wait()`等函数对于管理子进程的生命周期至关重要。 10. **目录和文件操作**：使用`chdir()`, `mkdir()`, `rmdir()`, `unlink()`...
fork.rar_Linux/Unix编程_C/C++_
08-11
在`fork()`后，父进程和子进程都会拥有不同的PID，但它们共享很多资源，如打开的文件描述符、环境变量等。 三、进程创建流程 1. 调用`fork()`：在父进程中创建子进程的副本。 2. 分配资源：子进程获得父进程的大...
linux进程之综合例程.zip
06-05
在实际的Linux进程管理中，还有其他重要的概念和函数，如`fork()`用于创建子进程，`wait()`和`waitpid()`用于等待子进程结束，`kill()`和`signal()`用于进程间通信和信号处理，以及`getpid()`和`getppid()`获取进程...
6、进程管理 – 看这一篇就够了
01-09
- `exit`是C标准库提供的函数，它会清理环境变量，调用析构函数，然后调用`_exit`系统调用退出进程。 - `_exit`直接退出进程，不执行任何清理工作，通常用于子进程快速退出。 12. **守护进程** - 守护进程...
【Linux】进程间通信——匿名管道
2201_76024104的博客
07-08 1112
1.：一个进程需要将它的数据发送给另一个进程，比如我们有两个进程，一个负责获取数据，另一个负责处理数据，这时第一个进程就要将获取到的数据交给第二个进程2.：多个进程间共享同样的资源3.：一个进程需要给其他进程发送消息，通知他们发生了某种事件4.：有些事件需要完全控制另一个进程，比如我们在使用gdb调试时，gdb就是一个进程，它控制了我们要调试的进程进程之前是有互相传递信息的需求，但是，一个进程不可能去另一个进程的地址空间中取信息，所以这就要求操作系统去提供一块交换数据的空间来供进程之间使用。
建立共享linux第三方软件仓库
Znj1421304181的博客
07-08 200
【代码】建立共享linux第三方软件仓库。
【linux/shell】linux如何去除字符串中空格
qq_35902025的博客
07-06 429
linux如何去除字符串中空格 tr命令可以用来替换或删除字符 sed是一个流编辑器，可以用来处理文本
Linux 系统安全加固：深入 SELinux 与 AppArmor
weixin_39372311的博客
07-08 845
SELinux 和 AppArmor 是两款强大的 Linux 安全模块，它们可以帮助你加固 Linux 系统安全，防止未经授权的访问和恶意行为。通过学习它们的原理、配置和使用方法，你可以更好地保护 Linux 系统安全，确保其稳定运行。
【Linux系列2】Cmake安装记录
kewaqi618的博客
07-08 1029
主要介绍Cmake的安装方法，及自己安装的过程
nginx安装（win和linux）
f552126506的博客
07-07 564
nginx安装（win和linux）
RedHat运维-LinuxSELinux基础4-端口绑定SELinux上下文
a15735748145a的博客
07-06 650
12. 将60001/tcp端口上的SELinux上下文由http_port_t调整为gopher_port_t的方法是______________________；13. 将60002/tcp端口上的SELinux上下文由gopher_port_t调整为ssh_port_t的方法是______________________；14. 将60003/tcp端口上的SELinux上下文由ssh_port_t调整为http_port_t的方法是_______________________；
Linux —— 进程间通信
最新发布
学习C++的小陈同学
07-11 635
本篇整理了关于进程间通信的内容，以及详解的介绍了两种进程间通信的方式，以及相关的接口和代码演练
如果想让子进程先执行，父进程后执行，利用wait()/waitpid()函数怎样修改程序实现。
03-27
可以在父进程中调用wait()/waitpid()函数，等待子进程结束后再执行父进程的代码。具体代码如下： ``` #include #include #include <sys/wait.h> int main() { int pid = fork(); if (pid == 0) { // 子进程 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值