unix系统编程day02--Liunx中exec函数族和回收进程函数讲解

最新推荐文章于 2022-02-09 23:51:23 发布
最新推荐文章于 2022-02-09 23:51:23 发布
阅读量195 收藏
点赞数
分类专栏： unix系统编程 unix系统编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38081836/article/details/86714659
版权

exec函数组

作用：在程序运行的过程中，再执行一个完整的程序。

execlp函数

  • 解释：其中l表示list，p表示PATH。
  • 作用：借助PATH环境变量，加载一个进程，新进程会清空原进程的虚拟地址空间的0-3G空间，但是进程id不会变。
  • 函数原型：int execlp(const char * filename, const char * filename, const char * arg0, const char * arg1, … , NULL)。
  • 返回值：成功无返回，失败返回-1。
  • 函数解释：后面的参数为命令行参数，第一个参数arg0一般没有用，后面才是对应的真正的参数，并且由于是命令行参数，所以最后一定要有一个NULL参数作为哨兵。

通过运行一个程序来实现子进程运行ls命令：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
extern char ** environ;

int main(void) {
    pid_t pid = 0;
    pid = fork();
    if(pid < 0) {
        perror("fork error");
        exit(1);
    } else if(pid == 0) {
        execlp("ls", "ls", "-al", NULL);
    } else {
        sleep(1);
        printf("I'm father");
    }
    return 0;
}

注：一定要注意execlp的参数，后面的arg0一般为无用参数，一定要加NULL作为哨兵结尾！

execl函数

  • 作用：加载一个进程，通过路径+程序名，无PATH环境变量参与
  • 函数原型：int execl(const char * filename, const char * filename, const char * arg0, const char * arg1, … , NULL); 可见名字中没有了p所以没有环境变量，所以filename要写绝对路径。
  • 返回值：成功无返回，失败返回-1

使用execl调用ls：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
extern char ** environ;

int main(void) {
    pid_t pid = 0;
    pid = fork();
    if(pid < 0) {
        perror("fork error");
        exit(1);
    } else if(pid == 0) {
        execl("/bin/ls", "ls", "-al", NULL);
    } else {
        sleep(1);
        printf("I'm father");
    }
    return 0;
}

注：既然是程序的绝对路径，所以我们可以运行我们自定义的程序，还是要注意参数，最后加NULL！！！

execle函数

  • 解释：e表示environ的意思，即环境变量
  • 函数原型：int execle(const char * path, const char * arg0, const char * arg1, … , NULL, char * const envp[]);

execv函数

  • 解释：v表示argv的意思，顾名思义，后边的那一堆参数可以用一个结构体来代替了，所执行的程序依然用绝对路径表示。
  • 函数原型：int execv(const char * path, char * const argv[]);
    注：argv数组最后一个元素为NULL；
    使用execv函数执行ls的程序：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
extern char ** environ;

int main(void) {
    pid_t pid = 0;
    pid = fork();
    if(pid < 0) {
        perror("fork error");
        exit(1);
    } else if(pid == 0) {
        char *argv[] = {"ls", "-al", NULL};
        execv("/bin/ls", argv);
    } else {
        sleep(1);
        printf("I'm father");
    }
    return 0;
}

注：参数最后一定为NULL

execvp函数

  • 解释：使用环境变量（p）并且把参数用数组表示
  • 函数原型：int execvp(const char * file, char * const argv[]);

execve函数

  • 解释：使用数组参数，使用environ环境变量
  • 函数原型：int execve(const char * path, char * const argv[], char * const envp[]);
    总结：l表示参数要list出来，v表示参数要数组起来，e表示要引入环境变量，p表示用到PATH环境变量，然后组合一下总共有6个函数，两个用不到环境变量的，然后两两组合的四个，都是exec开头。所有的exec族函数成功无返回，失败返回-1。

复习使用dup2重定向输出，把输出重定向到out文件

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
extern char ** environ;

int main(void) {
    int fd = open("out", O_CREAT | O_RDWR, 0777);
    dup2(fd, 1);
    pid_t pid = 0;
    pid = fork();
    if(pid < 0) {
        perror("fork error");
        exit(1);
    } else if(pid == 0) {
        char *argv[] = {"ls", "-al", NULL};
        execv("/bin/ls", argv);
    } else {
        sleep(1);
        printf("I'm father");
    }
    return 0;
}

简单的记忆：dup2(a, b)可以简单的记为把描述符a移到描述符b的位置（看个人理解）。

回收子进程

孤儿进程

  • 孤儿进程：父进程先于子进程结束，则子进程成为孤儿进程，子进程的父进程成为init进程，称为init进程领养孤儿过程，父亲结束后，儿进程的getppid（）为1，通过查看1表示的是init进程。init进程又称为init进程孤儿院。

僵尸进程

  • 僵尸进程：进程终止，父进程尚未回收，子进程的0-4G虚拟地址全部释放，但是子进程残留资源（PCB）一直存在在内核中，变成僵尸进程，残留的目的就是让父进程回收，想要父进程获得死亡状态。
    制作僵尸进程代码：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main(void) {
    pid_t pid = 0;
    pid = fork();
    if(pid < 0) {
        perror("fork error");
        exit(1);
    } else if(pid == 0) {
        printf("I'm child, I Will sleep 10s\n");
        sleep(10);
        printf("-----------child die----------\n");
    } else {
        while(1) {
            sleep(1);
            printf("I'm father pid = %d, my son = %d\n", getpid(), pid);
        }
    }
    return 0;
}

我们发现：出现了一个僵尸进程
f21d12e6dad0df8933cb6416cf5dba01.png

回收子进程函数

一个进程在终止的时候会关闭所有的文件描述符，释放用户空间分配的内存等资源，但是他的PCB还保留着，内核存了一些信息：如果正常终止，则保存着退出状态，如果异常终止则保存导致异常终止的信号是哪个，这个进程的父进程可以调用wait或者waitpid获取这些信息，然后彻底清楚掉这个进程，我们知道一个进程的退出状态可以在shell中用$?查看，因为shell是他的父进程，当他终止时shell可以调用wait或者waitpid来获取他的退出状态同时彻底清楚掉这个进程。

wait函数

  • 函数原型：pid_t wait(int * staus)
  • 参数：staus为传出参数，表示进程结束的状态是正常退出还是异常退出异常的时候保存的是信号
  • 返回值：成功返回被回收的进程号，否则返回-1
  • wait会阻塞函数知道子进程被回收之后程序才会继续运行下去
  • 作用：
    1. 阻塞等待子进程退出
    2. 回收子进程的PCB资源
    3. 获取子进程的状态
      通过wait回收一个子进程的程序（暂时不获取退出状态）：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main(void) {
    pid_t pid = 0, wpid = 0;
    pid = fork();
    if(pid < 0) {
        perror("fork error");
        exit(1);
    } else if(pid == 0) {
        printf("I'm child, I Will sleep 10s\n");
        sleep(10);
        printf("-----------child die----------\n");
    } else {
        wpid = wait(NULL);
        if(wpid < 0) {
            perror("wait error");
            exit(1);
        }
        while(1) {
            sleep(1);
            printf("I'm father pid = %d, my son = %d\n", getpid(), pid);
        }
    }
    return 0;
}
  • 获取子进程的退出状态，根据传出参数status
    需要掌握四个宏函数来确定具体的退出原因，我们知道在Linux中所有的异常退出都是由于信号引起。
宏函数
  1. WIFEXITED(status)：如果返回为非零则表示子进程正常退出。可以记（WAIT IF EXITED）。
  2. WEXITSTATUS(status)：如果1位真则执行该宏来确定返回值。可以记忆（WAIT EXIT STATUS）即wait退出状态。
  3. WIFSIGNALED(status)：如果返回值为非零，那么表示异常退出，需要调用4来确定是哪个信号导致异常退出。
  4. WTERMSIG(status)：如果3为真，则执行这个来查看具体是哪个信号导致程序异常退出。可以记忆 WAIT TREM SIGNAL wait的退出信号是多少
    下面我们通过wait回收子进程并确定正常退出的返回值是多少：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main(void) {
    pid_t pid = 0, wpid = 0;
    int status;
    pid = fork();
    if(pid < 0) {
        perror("fork error");
        exit(1);
    } else if(pid == 0) {
        printf("I'm child, I Will sleep 10s\n");
        sleep(3);
        printf("-----------child die----------\n");
        return 19;
    } else {
        wpid = wait(&status);
        if(wpid < 0) {
            perror("wait error");
            exit(1);
        }
        if(WIFEXITED(status)) {
            printf("return value = %d\n", WEXITSTATUS(status));
        }
        if(WIFSIGNALED(status)) {
            printf("killed by signal %d\n", WTERMSIG(status));
        }
    }
    return 0;
}

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

然后我们使用信号终止一个程序来看一下结果，代码就是把上面的代码子进程睡眠改为60秒，方便我们使用kill来终止它。
结果为：
在这里插入图片描述
可以看到被15号信号终止，查看所有的信号可以用 kill -l在终端来查看

waitpid函数

  • 函数原型：pid_t waitpidwaitpid(pid_t pid, int *stat_loc, int options);
  • 其中第三个参数options为0的时候为阻塞方式，WNOHANG为非阻塞方式
  • 作用：用来回收指定进程。
  • 第一个参数如果>0则回收指定的进程，如果为-1表示回收任意子进程，如果为0则回收和当前调用waitpid函数的进程同组的任意子进程，<-1回收指定进程组内的任意子进程
  • 返回值：如果参3为0则成功返回回收的pid否则返回-1，如果为WNOHANG如果回收成功返回对应的pid，否则返回0

总结

exec函数族：

  • execlp --p表示PATH环境变量，运行指定的程序，需要PATH环境变量的支持
    l： list
  • execl 运行自己的程序，需要指定绝对路径
  • execv：
    v：表示argv，意思是把参数放在一个char * argv[]里面
  • execve
  • execle
    回收子进程：
    wait（status）函数：
    作用：
      1. 阻塞回收子进程
      2. 回收子进程的PCB资源
      3. 获取子进程的退出状态
    1）WIFEXITED（）True
        WEXITSTATUS（）获取退出状态
    2）WIFSIGNALED（）True
        WTERMSIG（）获取让程序异常退出的信号
    waitpid：
  • 参1：
    pid>0：回收指定的pid函数
    pid=-1：回收任意子进程
    pid=0：回收本组的任意子进程
    pid<-1：回收指定组的任意子进程
  • 参2：staus同wait函数
  • 参3：options=0，阻塞方式回收，成功返回pid，失败返回-1
    options=WNOHANG，非阻塞方式回收，成功返回pid，失败返回0。
zephyr_pro
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux下的excel函数调用函数调用,逐层分析fork()函数与exec()函数
weixin_33729566的博客
05-04 987
姓名：倪群学号：SA12226209班级：嵌入式一班实验题目：进程的创建与可执行程序的加载实验环境：ubuntu12.04gcc编译工具链 Geany实验内容：fork()和exec()函数(这里代指exec函数族)的作用分别是为当前父进程生成一个子进程以及在执行一个新进程以替换当前进程执行内容和上下文环境。其中fork()函数会通过创建一系列子进程需要的数据结构(包括task_struct)，并...
exec函数族和wait函数解决僵尸进程
njrdear的博客
05-11 715
【案例 1】若子进程p1​是其父进程p的先决进程，基于wait函数使得进程同步。 #include <stdio.h> #include <stdlib.h> #include <sys/wait.h> int main(){ pid_t tempPid, tempW; tempPid = fork(); if(tempPid == -1){ perror("fork error"); exit(1); }else if(tempPid == 0){//c
僵尸进程（转）
maopig的专栏
09-27 1167
前面的文章中，我们已经了解了父进程和子进 程的概念，并已经掌握了系统调用exit的用法，但可能很少有人意识到，在一个进程调用了exit之后，该进程并非马上就消失掉，而是留下一个称为僵尸进 程（zombie）的数据结构。在linux进程的5种状态中，僵尸进程是非常特殊的一种，它已经
linux基础——进程的退出及资源回收
跑不了的你的博客
02-05 4845
文章目录进程的退出returen 和 exit代码示例注册进程结束调用函数代码示例（on_exit）：atexit代码示例（atexit）进程资源的回收代码示例wait回收进程资源代码示例waitpid代码示例给指定进程发送信号（kill）僵尸进程代码示例在进程的虚拟地址空间加载新的映像代码示例使用system启动新的可执行程序代码示例 进程的退出 returen 和 exit return只是...
父进程等待子进程终止 wait, WIFEXITED, WEXITSTATUS
热门推荐
Phoenix_FuliMa
12-06 5万+
wait()的函数原型是： #include    #include   pid_t wait(int *status) 进程一旦调用了wait，就立即阻塞自己，由wait自动分析是否当前进程的某个子进程已经退出。如果让它找到了这样一个已经变成僵尸的子进程，wait就会收集这个子进程的信息，并把它彻底销毁后返回；如果没有找到这样一个子进程，wait就会一直阻塞在这里，直到有一个出现
Linux学习记录--进程控制相关系统调用
StarFlex
04-17 3399
系统调用：进程控制 fork系统调用 函数作用：创建一个子进程 形式：pid_tfork(void); pid_t vfork(void); 说明：使用vfork创子进程时，不会进程父进程的上下文 返回值：[返回值=-1]子进程创建失败 [返回值=0]子进程创建成功 [返回值>0]对父进程返回子进程PID 举例： #include #include #inc
【C语言】【unix c】进程资源的回收
刘星燎
08-28 928
【C语言】【unix c】进程资源的回收
exec命令
iteye_17363的博客
10-26 484
shell的内建命令exec将并不启动新的shell，而是用要被执行命令替换当前的shell进程，并且将老进程的环境清理掉，而且exec命令后的其它命令将不再执行。 因此，如果你在一个shell里面，执行exec ls那么，当列出了当前目录后，这个shell就自己退出了，因为这个shell进程已被替换为仅仅执行ls命令的一个进程，执行结束自然也就退出了。为 了避免这个影响我们的使用，一般将ex...
Linux系统编程 —— exec函数族
柯西丶不是你的博客
04-25 233
fork 创建子进程之后执行的是和父进程相同的程序（可能执行不同的代码分支）。 子进程调用exec函数执行另一程序，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。 exec并不传创建新进程，所以调用exec前后该进程的id并未改变。 exec函数族 （l => list ，p => path） int execl(const char *path...
Linux系统exec命令
be happy
01-15 9138
shell的内建命令exec将并不启动新的shell，而是用要被执行命令替换当前的shell进程，并且将老进程的环境清理掉，而且exec命令后的其它命令将不再执行。  因此，如果你在一个shell里面，执行exec ls那么，当列出了当前目录后，这个shell就自己退出了，因为这个shell进程已被替换为仅仅执行ls命令的一个进程，执行结束自然也就退出了。为了避免这个影响我们的使用，一般将exe
linux exec创建进程,LinuxC创建回收进程fork、exec、wait、waitpid函数的理解
weixin_42500625的博客
04-30 200
1. forkint pid = fork();if (pid == -1 ) {//返回-1，说明fork失败perror("fork");exit(1);} else if (pid > 0) {//返回子进程pid，说明是父进程} else if (pid == 0) {//返回0，说明是子进程}fork出来的子进程和父进程相同的是：全局变量、.data、.text、堆、栈、环境变量、...
4.1 进程的秘密(父子进程,exec函数族,守护进程)
weixin_41838250的博客
08-20 361
父子进程: 1,Linux下创建进程的函数为fork();被创建的进程为子进程,发起创建的进程为父进程;他们共用所有资源.通过创建函数子进程函数fork的返回值区分;PID为0,为子进程，大于0为父进程. 2,子进程创建后,对于fork()的返回值,父进程返回子进程的PID,子进程返回0;通过getpid()可以获取当前进程pid,通过getppid()获取当前进程的父进程的pid. 3,通过vfork()也可创建子进程，与fork()不同的时,fork()是复制父进程的所有资源,v...
进程的创建、回收和终止
liupc的学习笔记
05-29 1988
一、进程的创建：       //内核里面只有fork 和exec两种可以创建进程。其他方式都是使用的这两种方式，如system()封装了exec。system()fork()exec()popen()二、进程的回收：孤儿进程僵尸进程wait()三、进程的终止：main函数的自热返回；调用exit函数；调用_exit函数；调用abort函数；接收能导致进程终止的信号Ctrl +c SSIGINT ...
linux exec用法总结
我的专栏
01-14 3万+
linux exec用法总结 先总结一个表： exec命令 作用 exec ls 在shell中执行ls，ls结束后不返回原来的shell中了 exec  将file中的内容作为exec的标准输入 exec >file 将file中的内容作为标准
linux--exec命令
daobuxinzi的博客
02-09 4837
shell的内建命令exec将并不启动新的shell，而是用要被执行命令替换当前的shell进程，并且将老进程的环境清理掉，而且exec命令后的其它命令将不再执行。 　　因此，如果你在一个shell里面，执行exec ls；那么，当列出了当前目录后，这个shell就自己退出了，因为这个shell进程已被替换为仅仅执行ls命令的一个进程，执行结束自然也就退出了。为了避免这个影响我们的使用，一般将exec命令放到一个shell脚本里面，用主脚本调用这个脚本，调用点处可以用bash a.sh，（a.sh就是存放
Linux进程实践(3) --进程终止与exec函数族
weixin_30851409的博客
02-18 214
进程的几种终止方式(1)正常退出 从main函数返回[return] 调用exit 调用_exit/_Exit(2)异常退出 调用abort产生SIGABOUT信号 由信号终止Ctrl+C[SIGINT] ...(并不完全,如return/pthread_exit等)测试[exit/_exit]//尝试查看该程序的打印输出 int main() { ...
Linux系统编程--3（exec 函数族，僵尸进程和孤儿进程，wait和wait_pid回收子进程)
LXY的博客
08-12 488
exec 函数族 fork 创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支） ，子进程往往要调用一种 exec 函数以执行另一个程序。当进程调用一种 exec 函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序 的启动例程开始执行。调用 exec 并不创建新进程，所以调用 exec 前后该进程的 id 并未改变。 将当前进程的.text、.data 替换为所要加载的程...
-a -f 在liunx 中代表啥意思
最新发布
06-08
-a 和 -f 是 Linux 命令中的选项参数。 -a 选项参数通常用于 ls 命令中，表示显示所有文件和目录，包括隐藏文件和目录。 -f 选项参数通常用于 rm 命令中，表示强制删除文件或目录，不提示用户确认操作。 所以，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值