《Linux C编程实战》笔记:进程操作之退出,执行,等待

发布时间:2023年12月19日

进程退出

进程退出表示进程即将运行结束。在Linux中退出分为正常退出和异常退出。

正常退出:

  1. 在main函数中执行return
  2. 调用exit函数
  3. 调用_exit函数

异常退出:

  1. 调用abort函数
  2. 收到某个信号,这个信号是程序终止

退出方式比较

  1. exit和return的区别:exit是一个函数,有参数;而return是函数执行完后的返回。exit把控制权交给系统,而return将控制权交给调用函数。
  2. exit和 abort的区别:exit是正常终止进程,而about是异常终止。
  3. exit(int exit_code): exit中的参数exit_code为0代表进程正常终止,若为其他值表示程序执行过程中有错误发生,比如溢出、除数为0。
  4. exit()和_exit()的区别:exit在头文件stdlib.h中声明,而_exit()声明在头文件unistd.h中。两个函数均能正常终止进程,但是_exit()会执行后立即返回给内核,而exit()要先执行一些清除操作,然后将控制权交给内核。

父子进程终止的先后顺序不同会产生不同的结果。在子进程退出前父进程先退出,则系统会让 init进程接管子进程(前面有代码演示过)。当子进程先于父进程终止,而父进程又没有调用wait 函数等待子进程结束,子进程进入僵死状态,并且会一直保持下去除非系统重启。子进程处于僵死状态时,内核只保存该进程的一些必要信息以备父进程所需。此时子进程始终占用着资源,同时也减少了系统可以创建的最大进程数。如果子进程先于父进程终止,且父进程调用了wait或waitpid函数,则父进程会等待子进程结束。

执行新程序

使用fork或vfork创建子进程后,子进程通常会调用exec函数来执行另外一个程序。系统调用exec用于执行一个可执行程序以代替当前进程的执行映像。

注意:exec调用并没有生成新进程。一个进程一旦调用exec函数,它本身就“死亡”了,系统把代码段替换成新的程序的代码,废弃原有的数据段和堆栈段,并为新程序分配新的数据段与堆栈段,惟一保留的就是进程ID。也就是说,对系统而言,还是同一个进程,不过执行的已经是另外一个程序了。

Linux下,exec函数族又6种不同的调用形式,如下:

  1. execl

    • int execl(const char *path, const char *arg, ...);
    • 这个函数接受一个以空格分隔的参数列表,最后一个参数必须为 NULL

    execl("/bin/ls", "ls", "-l", (char *)NULL);

  2. execv

    • int execv(const char *path, char *const argv[]);
    • 这个函数接受一个参数数组,最后一个元素必须为 NULL

    char *args[] = {"ls", "-l", NULL}; execv("/bin/ls", args);

  3. execle

    • int execle(const char *path, const char *arg, ..., char *const envp[]);
    • execl 相似,但可以指定新程序的环境变量。

    execle("/bin/ls", "ls", "-l", (char *)NULL, envp);

  4. execve

    • int execve(const char *path, char *const argv[], char *const envp[]);
    • execv 相似,但可以指定新程序的环境变量。

    char *args[] = {"ls", "-l", NULL}; execve("/bin/ls", args, envp);

  5. execlp

    • int execlp(const char *file, const char *arg, ...);
    • execl 类似,但会在 PATH 环境变量指定的目录中查找可执行文件。

    execlp("ls", "ls", "-l", (char *)NULL);

  6. execvp

    • int execvp(const char *file, char *const argv[]);
    • execv 类似,但会在 PATH 环境变量指定的目录中查找可执行文件。

    char *args[] = {"ls", "-l", NULL}; execvp("ls", args);

这些函数执行成功时不会返回,而是将当前进程的映像替换为新的程序。如果函数调用失败,它们会返回 -1,并设置 errno 变量以指示错误的原因。

为了更好理解exec,首先要理解环境变量这个概念。Linux引入了环境变量的概念,包括用户的主目录,终端类型、当前目录等,它们定义了用户的工作环境,所以称为环境变量。可以使用env命令查看环境变量值,用户也可以修改这些变量值以定制自己的工作环境

示例程序1

演示环境变量的应用

#include<cstdlib>
#include<malloc.h>
#include<cstring>
#include <cstdio>
#include<ctime>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<cerrno>
using namespace std;
extern char **environ;
int main(int argc,char *argv[]){
    int i;
    printf("Argument:\n");
    for(int i=0;i<argc;i++)
        printf("argv[%d] is %s\n",i,argv[i]);
    printf("Environment:\n");
    for(int i=0;environ[i]!=nullptr;i++)
        printf("%s\n",environ[i]);
    return 0;
}

还有很多环境变量,图片放不下了

命令行里输入命令env,环境变量和程序里应该是一样的

在C语言中,extern char **environ 是一个用于访问进程环境变量的外部变量声明。这个变量通常由操作系统或C库提供,用于存储当前进程的环境变量。

每个C程序在运行时都有一个环境变量表,其中包含了键值对形式的环境变量。environ 是一个指向字符串指针数组的指针,每个字符串指针指向一个环境变量的字符串。

通过访问 environ 变量,你可以迭代这个字符串指针数组,直到遇到一个空指针,表示环境变量列表的结束。每个字符串指针指向一个形如 "key=value" 的字符串,表示一个环境变量。

有一些系统和编译器提供了一个额外的参数,通常称为 envp,它是一个指向环境变量的字符串数组的指针。

int main(int argc, char *argv[],char **envp);

打印envp,也可以得到环境变量

int main(int argc,char *argv[],char **envp){
    int i;
    printf("Argument:\n");
    for(int i=0;i<argc;i++)
        printf("argv[%d] is %s\n",i,argv[i]);
    printf("Environment:\n");
    for(int i=0;envp[i]!=nullptr;i++)
        printf("%s\n",envp[i]);
    return 0;
}

这是main函数为上面形式的运行结果,确实可以打印环境变量

事实上无论是哪个exec函数,都是将可执行程序的路径、命令行参数和环境变量3个参数传递给可执行程序的main函数。

上面说到如果失败,即遇到错误的事件,exec函数会返回-1,以下是一些错误

?在 Linux 操作系统下,exec函数族可以执行二进制的可执行文件,也可以执行Shell脚本程序,但Shell脚本必须以下面所示的格式开头:第一行必须为:#! interpretername [arg]。其中 interpretername可以是Shell或其他解释器,例如,/bin/sh 或usr/bin/perl,arg是传递给解释器的参数。

示例程序2

演示exec函数的用法

processimage.cpp

这里写的是子进程到时候执行exec后执行的代码

#include<cstdio>
#include<sys/types.h>
#include<unistd.h>
int main(int argc,char *argv[],char **environ){
    int i;
    printf("I am a process image!\n");
    printf("My pid= %d,parent=%d\n",getpid(),getppid());
    printf("uid = %d,gid = %d\n",getuid(),getgid());
    for(i=0;i<argc;i++)
        printf("argv[%d]:%s\n",i,argv[i]);
}

getuidgetpid 是两个与进程和用户身份相关的系统调用函数。

  1. getuid 函数:

    • uid_t getuid(void);
    • 用于获取当前进程的用户实际用户标识(User ID)。返回值是用户的实际用户ID。
  2. getpid 函数:

    • pid_t getpid(void);
    • 用于获取当前进程的进程ID。返回值是当前进程的进程ID。

execve.cpp

#include<cstdio>
#include<sys/types.h>
#include <sys/wait.h>
#include<unistd.h>
#include<cstdlib>
int main(int argc,char *argv[],char **environ){
    pid_t pid;
    int stat_val;
    printf("Exec example\n");
    pid=fork();
    switch (pid)
    {
    case -1:
        perror("Process Creation failed\n");
        exit(1);
    case 0:
        printf("Child process is running\n");
        printf("My pid =%d,parentpid= %d\n",getpid(),getppid());
        printf("uid=%d,gid=%d\n",getuid(),getgid());
        execve("processimage",argv,environ);
        printf("process never go to here!\n");//是不会允许到这一句的
    default:
        printf("Parent process is running\n");
        break;
    }
    wait(&stat_val);
    exit(0);
}

注意顺序,先编译第一个程序,而且可执行文件名称要对应execve的参数

可以看到新程序进程的pid,ppid,uid和gid都保持了原来子进程的。调用execve之后,原有的子进程的映像被替代,所以那句打印永远不会执行

wait 函数的原型如下:

#include <sys/types.h>

#include <sys/wait.h>

pid_t wait(int *status);

  • pid_t 是进程ID的数据类型,通常是整数。
  • int *status 是一个指向整数的指针,用于存储子进程的终止状态。

wait 函数用于等待任意一个子进程的退出,并获取子进程的退出状态。其返回值是已经终止的子进程的进程ID。如果调用失败,返回值为 -1。

status 参数用于存储有关子进程终止状态的信息。如果不关心子进程的退出状态,可以将 status 设置为 NULL如果 status 不是 NULL,则可以使用一些宏来检查 status 中的信息,例如:

  • WIFEXITED(status):如果子进程正常终止(不是信号终止),返回非零。
  • WEXITSTATUS(status):获取子进程的退出状态,只有在 WIFEXITED(status) 为真时才有效。

执行新程序后的进程除了保持了原来的进程ID、父进程ID、实际用户ID和实际组ID之外,进程还保持了许多原有特征,主要有。

  1. 当前工作目录。
  2. 根目录。
  3. 创建文件时使用的屏蔽字。
  4. 进程信号屏蔽字。
  5. 未决警告。
  6. 和进程相关的使用处理器的时间。
  7. 控制终端。
  8. 文件锁。

等待进程结束

之前提到的僵死状态,如果父进程调用了wait或waitpid,就不会使子进程编程僵尸进程

#include<sys/types.h>
#include <sys/wait.h>
pid_t wait(int *statloc);
pid_t waitpid(pid_t pid, int *statloc,int options);

wait函数使父进程暂停执行,直到它的一个子进程结束为止。该函数的返回值是终止运行的子进程的PID。参数 statloc所指向的变量存放子进程的退出码(注意statloc本身不等于退出码),即从子进程的main 函数返回的值或子进程中exit函数的参数。如果statloc不是一个空指针,状态信息将被写入它指向的变量。

头文件sys/wait.h中定义了解读进程退出状态的宏。

注:status就是通过statloc返回来的值

  1. WIFEXITED(status)

    • 如果子进程正常终止(不是由于信号),则返回非零值。
  2. WEXITSTATUS(status)

    • 如果 WIFEXITED(status) 为真,该宏返回子进程的退出状态。这是子进程传递给 exit_exit 函数的值。
  3. WIFSIGNALED(status)

    • 如果子进程是因为信号而终止,而不是正常退出,则返回非零值。
  4. WTERMSIG(status)

    • 如果 WIFSIGNALED(status) 为真,该宏返回导致子进程终止的信号编号。
  5. WIFSTOPPED(status)

    • 如果子进程当前已经停止,则返回非零值。这通常是由于接收到一个信号,要求进程停止执行。
  6. WSTOPSIG(status)

    • 如果 WIFSTOPPED(status) 为真,该宏返回导致子进程停止的信号编号。
  7. WIFCONTINUED(status)

    • 如果子进程由于接收到 SIGCONT 信号而继续运行,则返回非零值。

waitpid也用来等待子进程的结束,但它用于等待某个特定进程结束。参数pid指明要等待的子进程的PID。 参数 statloc的含义与wait函数中的statloc相同。options参数允许用户改变waitpid的行为,若将该参数赋值为WNOHANG,则使父进程不被挂起而立即返回并执行其后的代码。

下面是 waitpid 函数中 pid 参数不同取值的意义:

  1. pid > 0:

    • 表示等待具有进程ID为 pid 的子进程。
    • 如果该子进程还没有退出,则父进程会阻塞等待,直到子进程退出为止。
    • 如果子进程已经退出,父进程会立即返回。
  2. pid == -1:

    • 表示等待任意子进程,类似于 wait 函数。
    • 父进程会等待第一个终止的子进程,无论其进程ID是多少。
  3. pid == 0:

    • 表示等待与调用 waitpid 的父进程在同一个进程组的任意子进程。
    • 这对于等待同一作业中的任意子进程很有用。
  4. pid < -1:

    • 表示等待进程组ID为 pid 的任意子进程。
    • 这对于等待特定进程组中的任意子进程很有用。

以下是一些常用的 waitpid 选项及其对应的宏:

  1. WNOHANG:

    • 启用非阻塞模式,即如果没有子进程退出,则立即返回,而不会阻塞父进程。
  2. WUNTRACED:

    • 用于获取已经停止但尚未进入终止状态的子进程的状态信息。
  3. WCONTINUED:

    • 用于获取已经继续运行的子进程的状态信息。

这些宏可以与位运算结合使用,以同时指定多个选项。

如果想让父进程周期性地检查某个特定的子进程是否已经退出,可以按如下方式调用waitpid。

waitpid(child_pid, NULL,WNOHANG);

如果子进程尚未退出,它将返回0;如果子进程已经结束,则返回child _pid。调用失败时返回-1。失败的原因包括没有该子进程、参数不合法等。

注意:wait等待第一个终止的子进程,而 waitpid则可以指定等待特定的子进程。waitpid 提供了一个wait的非阻塞版本。有时希望取得一个子进程的状态,但不想使父进程阻塞,waitpid 提供了一个这样的选项: WNOHANG,它可使调用者不阻塞。如果一个没有任何子进程的进程调用wait函数,会立即出错返回。

示例程序3

演示wait的使用和子进程退出码的获得

#include<cstdlib>
#include<malloc.h>
#include<cstring>
#include <cstdio>
#include<ctime>
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/wait.h>
#include<fcntl.h>
#include<unistd.h>
#include<cerrno>
using namespace std;
int main(){
    pid_t pid;
    const char *msg;
    int k;
    int exit_code;
    printf("Study how to get exit code\n");
    pid=fork();
    switch (pid)
    {
    case 0:
        msg="Child process is running";
        k=5;
        exit_code=37;//这就是子进程的退出码
        break;
    case -1:
        perror("Process creation failed\n");
        exit(1);
    default:
        exit_code=0;
        break;
    }
    if(pid!=0){//父进程会执行这里
        int stat_val;
        pid_t child_pid;
        child_pid=wait(&stat_val);//父进程暂停等待子进程结束
        printf("Child process has exited,pid=%d\n",child_pid);
        if(WIFEXITED(stat_val))//通过这个判断子进程是否是正常结束的
            printf("Child exited with code %d\n",WEXITSTATUS(stat_val));//获得退出码
        else printf("Child exited abnormally\n");
    }
    else{//子进程会执行这里
        while (k-->0)
        {
            puts(msg);
            sleep(1);
        }
    }
    exit(exit_code);
}

运行结果:

文章来源:https://blog.csdn.net/ouliten/article/details/135082502
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。