1. 前言🚀
🌈之前在这两篇文章中
【Linux】进程详解:命令行参数、环境变量及地址空间-CSDN博客
我们已经了解过了进程的基本概念,这一章我们要进一步的学习进程,即 **「进程的创建和终止」**。
之前博客里面我们讲过了,现在只是来做个温习
创建进程有两种创建方式:
#include <unistd.h>
pid_t fork(); // 返回值有两个:子进程返回0,父进程返回子进程的PID,如果子进程创建失败返回-1
进程调用fork,当控制转移到内核中的fork代码后,内核做:
因此我们就可以知道fork()创建一个进程之所以会有两个返回值的原因
新创建的子进程机会和父进程一模一样,但是还是不完全一样
在之前的博客中就说过了fork()函数有两个返回值,子进程返回0,父进程返回子进程的PID,下面就需要解决三个问题。
通常,父子代码共享,父子不写入时,数据共享,当任意一方试图写入,便以写时拷贝的方式各自一份副本。 (进程的独立性)详情如下:
🔥 对于写时拷贝,有三个问题要注意:
一般情况下fork()函数不会调用失败,但是有两个情况下会使得fork()创建子进程失败:
exec
系列函数实现
了解进程创建之后,我们就要来了解一个进程的终止
进程终止做的事:
进程需要终止退出的情况有三种:
代码跑完,结果不正确的原因可以通过退出码确定,一旦出现异常,退出码就没有意义了,进程出异常,本质是因为进程收到了OS发给进程的信号。
得到进程退出码有不止一种方式,但是这里介绍一种大家最熟悉的得到进程退出码的方式。
如果想要写一个C/C++程序的代码,写的第一个函数一定是main(),而main()是由返回值的。
下面两个问题可以帮助你更好地理解进程退出码的意义?
进程退出码有很多,每一个退出码都有对应的字符串含义,帮助用户确认执行失败的原因。
我们可以使用 $?
来查看最近一个进程的退出码,如下:
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;
}
运行结果如下:
注意:这些退出码具体代表什么含义是人为规定的,不同环境下相同的退出码的字符串含义可能不同
正常终止(可以通过 echo $? 查看进程退出码):
int main()
{
printf("return 100\n");
return 100;
}
运行结果如下:
#include <unistd.h>
void exit(int status);
#include <unistd.h>
void exit(int status);
exit 最后也会调用 _exit, 但在调用 _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]#
相似点:
不同点:
联系:
注意 return 和 exit 区别
所以一定需要通过父进程通过进程等待的方式,来回收子进程的资源,同时为了搞清楚子进程完成任务的情况,也需要通过通过进程等待的方式获取子进程的退出信息。
在学习相关内容之前,我们先来理解一下子进程的 status 是啥意思,因为后面我们需要通过下面两个函数来做进程等待
我们发现这两个函数中都有一个参数status,而这个参数比较复杂且重要
🌈 上文说过,进程等待不仅是回收子进程的资源也需要获取子进程的退出信息,所以 status的作用就是获取退出的信息 。
status是一个输出型参数,即在wait()函数外面的变量,传入wait() 函数,然后在wait() 内部对wait() 进行操作,从而改变status
⭐ status不能简单的当作整形来看待,可以当作位图来看待。 在status的后16个比特位上,高8位表示进程退出的状态,即进程退出码。而后7位为进程终止的信号。第8个比特位是一个标志
有两种方法我们可以获取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
#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int*status);
返回值:
成功返回被等待进程pid,失败返回-1。
参数:
status为输出型参数,通过传入一个参数来获取被等待的子进程的退出状态。不关心则可以设置成为NULL
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参数控制)
下面分别对阻塞等待和非阻塞等待举出一个例子:
所以想要判断是否为阻塞或者非阻塞等待,就只要判断父进程在子进程运行的时候,可不可以自己运行自己的代码即可。
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.
#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;
}
用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。
当进程调用一种exec函数时
但是要注意两个问题❓
进程替换函数是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, ...)
函数参数
情况一:只调用系统中的可执行程序
#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;
}
运行结果如下:
通过上面六个函数的学习,大家一定可以发现其中其实存在一些规律,他们的后缀函数如下:
函数名 | 参数格式 | 是否要写成绝对路径 | 是否使用当前的环境变量 |
---|---|---|---|
execl | 列表 | ✔️ | ✔️ |
execlp | 列表 | ×(文件名即可) | ✔️ |
execle | 列表 | ✔️ | ×(自己设置环境变量) |
execv | 数组 | ✔️ | ✔️ |
execvp | 数组 | ×(文件名即可) | ✔️ |
execve | 数组 | ✔️ | ×(自己设置环境变量) |
【*★,°*:.☆( ̄▽ ̄)/$:*.°★* 】那么本篇到此就结束啦,如果我的这篇博客可以给你提供有益的参考和启示,可以三连支持一下 💖!💞