进程的创立及相关api,exec函数的运用

  1. 示例

  2. /*exec函数示例*/  

  3. #include <stdio.h>   
  4. #include <unistd.h>   
  5.   
  6. int main(void)  
  7. {  
  8.     int flag;  
  9.     pid_t pid;  
  10.     char *const argv[] = {“%U”, “–user-data-dir=/home/Administrator/.chromiun”, NULL};  
  11.     //exec把当前进程印象替换成新的程序文件,故调用进程被覆盖
      
  12.   
  13.     // 如果不指定全路径,则只检查PATH变量中存储的命令
      
  14.     if((pid = fork())==0) {  
  15.         printf(“in child process 1……\n”);  
  16.         //flag = execvp(“./hello”, NULL);
      
  17.         //envp变量的用   
  18.         char *envp[]={“PATH=.”, NULL};  
  19.         flag = execve(“hello”, NULL, envp);  
  20.         if(flag == -1)  
  21.             printf(“exec error!\n”);  
  22.     }  
  23.   
  24.     if((pid = fork())==0) {  
  25.         printf(“in child process 2……\n”);  
  26.         //执行ls命令   
  27.         flag = execlp(“ls”, “-al”, NULL);  
  28.         if(flag == -1)  
  29.             printf(“exec error!\n”);  
  30.     }  
  31.       
  32.     if((pid = fork())==0) {  
  33.         printf(“in child process 3……\n”);  
  34.         //启动chrome浏览器   
  35.         flag = execv(“/usr/bin/chromium-browser”, argv);  
  36.         if(flag == -1)  
  37.             printf(“exec error!\n”);  
  38.     }  
  39.     printf(“in parent process ……\n”);  
  40.     return 0;  
  41. }  

  42. hello程序

  43. #include <stdio.h>   

  44.   
  45. int main(void)  
  46. {  
  47.     printf(“Hello world!\n”);  
  48.     return 0;  
  49. }  

  50. 运行结果

  51. root@Ubuntu:…/Linux_C/Process# ./exec_t  

  52. in child process 1……  
  53. in parent process ……  
  54. in child process 3……  
  55. root@ubuntu:…/Linux_C/Process# in child process 2……  
  56. Hello world!  
  57. exec_t    fifo_read.c   fork_1.c  hello.c    msg_send.c   signal_1.c  
  58. exec_t.c  fifo_write.c  hello     msg_receive.c  semop_P_V.c  
  59. 已在现有的浏览器会话中创建新的窗口。  

linux c语言 fork() 和 exec 函数的简介和用法

 

      假如我们在编写1个c程序时想调用1个shell脚本或者执行1段 bash
shell命令, 应该如何实现呢?

      其实在<stdlib.h>
这个头文件中包含了1个调用shell命令或者脚本的函数 system();直接把
shell命令作为参数传入 system函数就可以了, 的确很方便. 关于system
有一段这样的介绍:   system 执行时内部会自动启用fork() 新建1个进程, 
效率没有直接使用fork() 和 exec函数高.

 

       那么这篇文章其实就是介绍一下fork() 和 exec函数的用法,
以及如何使用它们来替代system函数.

      

一、进程的创建fork()函数

图片 1

1. fork() 函数

图片 2

1.1 fork() 函数的作用

       一般来讲, 我们编写1个普通的c程序, 运行这个程序直到程序结束,
系统只会分配1个pid给这个程序, 也就就说,
系统里只会有一条关于这个程序的进程.

 

        但是执行了fork() 这个函数就不同了. 

        fork 这个英文单词在英文里是”分叉”意思,  fork()
这个函数作用也很符合这个意思. 
它的作用是复制当前进程(包括进程在内存里的堆栈数据)为1个新的镜像.
然后这个新的镜像和旧的进程同时执行下去. 相当于本来1个进程, 遇到fork()
函数后就分叉成两个进程同时执行了. 而且这两个进程是互不影响

 

        参考下面这个小程序:

 

[cpp] view
plain copy

 

  1. int fork_3(){  
  2.     printf(“it’s the main process step 1!!\n\n”);  
  3.   
  4.     fork();  
  5.   
  6.     printf(“step2 after fork() !!\n\n”);  
  7.   
  8.     int i; scanf(“%d”,&i);   //prevent exiting  
  9.     return 0;  
  10. }  

 

          在这个函数里, 共有两条printf语句,
但是执行执行时则打出了3行信息. 如下图: 

 由fork创建的新进程被称为子进程(child
process)。该函数被调用一次,但返回两次。两次返回的区别是子进程的返回值是0,而父进程的返回值则是
新子进程的进程ID。将子进程ID返回给父进程的理由是:因为一个进程的子进程可以多于一个,所有没有一个函数使一个进程可以获得其所有子进程的进程ID。fork使子进程得到返回值0的理由是:一个进程只会有一个父进程,所以子进程总是可以调用getppid以获得其父进程的进程ID(进程
ID  0总是由交换进程使用,所以一个子进程的进程ID不可能为0)。

图片 3

 

            为什么呢, 因为fork()函数将这个程序分叉了啊,  见下面的图解:

图片 4

 

         可以见到程序在fork()函数执行时都只有1条主进程, 所以 step 1
会被打印输出1次.

         执行 fork()函数后,  程序分叉成为了两个进程, 1个是原来的主进程, 
另1个是新的子进程, 它们都会执行fork() 函数后面的代码, 所以 step2 会被
两条进程分别打印输出各一次, 屏幕上就总共3条printf 语句了!

 

         可以见到这个函数最后面我用了 scanf()函数来防止程序退出, 
这时查看系统的进程, 就会发现两个相同名字的进程:

 

 

 

如上图, pid 8808 那个就是主进程了, 而 pid  8809那个就是子进程啊,
因为它的parent pid是 8808啊!

          

          需要注意的是, 假如没有做特殊处理, 子进程会一直存在,
即使fork_3()函数被调用完成,  子进程会和主程序一样,返回调用fork_3()
函数的上一级函数继续执行, 直到整个程序退出.

 

          可以看出, 假如fork_3() 被执行2次,  主程序就会分叉两次,
最终变成4个进程, 是不是有点危险. 所以上面所谓的特殊处理很重要啊!

 

   
子进程和父进程继续执行fork之后的指令。子进程是父进程的复制品。例如,子进程获得父进程数据空间、堆和栈的复制品。注意,这是子进程拥有的拷贝。父、子进程并共享这些存储部分。如果正文段是只读的,则父、子进程共享正文段。

1.2 区别分主程序和子程序.

        实际应用中, 单纯让程序分叉意义不大, 我们新增一个子程序,
很可能是为了让子进程单独执行一段代码. 实现与主进程不同的功能.

         要实现上面所说的功能,
实际上就是让子进程和主进程执行不同的代码啊.

         所以fork() 实际上有返回值, 而且在两条进程中的返回值是不同的,
在主进程里 fork()函数会返回主进程的pid,   而在子进程里会返回0!  
所以我们可以根据fork() 的返回值来判断进程到底是哪个进程, 就可以利用if
语句来执行不同的代码了!

 

        如下面这个小程序fork_1():

 

[cpp] view
plain copy

 

  1. int fork_1(){  
  2.     int childpid;  
  3.     int i;  
  4.   
  5.     if (fork() == 0){  
  6.         //child process  
  7.         for (i=1; i<=8; i++){  
  8.             printf(“This is child process\n”);  
  9.         }  
  10.     }else{  
  11.         //parent process  
  12.         for(i=1; i<=8; i++){  
  13.             printf(“This is parent process\n”);  
  14.         }  
  15.     }  
  16.   
  17.     printf(“step2 after fork() !!\n\n”);  
  18. }  

        我对fork() 函数的返回值进行了判断, 如果 返回值是0,
我就让认为它是子进程, 否则是主程序. 
那么我就可以让这两条进程输出不同的信息了.

 

       

          输出信息如下图:

图片 5

 

          可以见到 子程序和主程序分别输出了8条不同的信息, 
但是它们并不是规则交替输出的, 因为它们两条进程是互相平行影响的,
谁的手快就在屏幕上先输出,  每次运行的结果都有可能不同哦.

 

        下面是图解:

图片 6

 

          由图解知两条进程都对fork()返回值执行判断,  在if
判断语句中分别执行各自的代码.  但是if判断完成后, 
还是会回各自执行接下来的代码. 所以 step2 还是输出了2次.

    

1.4 使用exit() 函数令子进程在if 判断内结束.

          参考上面的函数, 虽然使用if 对 fork() 的返回值进行判断, 
实现了子进程和 主进程在if判断的范围内执行了不同的代码, 
但是就如上面的流程图, 一旦if执行完成, 他们还是会各自执行后面的代码. 

          通常这不是我们期望的, 
我们更多时会希望子进程执行一段特别的代码后就让他结束, 
后面的代码让主程序执行就行了.

          这个实现起来很简单, 在子程序的if 条件内最后加上exit()
函数就ok了.

 

         将上面的fork_1()函数修改一下, 加上exit语句:

 

[cpp] view
plain copy

 

  1. int fork_1(){  
  2.     int childpid;  
  3.     int i;  
  4.   
  5.     if (fork() == 0){  
  6.         //child process  
  7.         for (i=1; i<=8; i++){  
  8.             printf(“This is child process\n”);  
  9.         }  
  10.         exit(0);  
  11.     }else{  
  12.         //parent process  
  13.         for(i=1; i<=8; i++){  
  14.             printf(“This is parent process\n”);  
  15.         }  
  16.     }  
  17.   
  18.     printf(“step2 after fork() !!\n\n”);  
  19. }  

       再看看输出:

 

图片 7

 

            可以见到, step2只输出1次了,   这是因为子程序在
if条件内结束了啊, 一旦 if 判断成, 就只剩下1个主进程执行下面的代码了,
这正是我们想要的!

            注意: exit() 函数在 stdlib.h 头文件内

 

流程图:

图片 8

 

 

 

   
现在很多的实现并不做一个父进程数据段和堆的完全拷贝,因为在fork之后经常跟随着exec。作为替代,使用了写时复制(copy-on-write,cow)的技术。这些区域由父、子进程共享,而且内核将他们的存取许可权改变位只读的。如果有进程试图修改这些区域,则内核包异常,典型的是虚存系统中的“页”,做一个拷贝。

1.4 使用wait() 函数主程序等子程序执行完成(退出)后再执行.   

 

        由上面例子得知,  主程序和子程序的执行次序是随机的, 
但是实际情况下, 通常我们希望子进程执行后,  才继续执行主进程. 

        例如对于上面的fork_1()函数, 我想先输出子进程的8个 “This is
child process”  然后再输出 8个 主进程”This is parent process”, 改如何做?

        wait()函数就提供了这个功能,    在if 条件内的  主进程呢部分内
加上wait() 函数, 就可以让主进程执行fork()函数时先hold 住,
等子进程退出后再执行, 通常会配合子进程的exit()函数一同使用.

 

        我将fork_1()函数修改一下, 添加了wait()语句:

 

[cpp] view
plain copy

 

  1. int fork_1(){  
  2.     int childpid;  
  3.     int i;  
  4.   
  5.     if (fork() == 0){  
  6.         //child process  
  7.         for (i=1; i<=8; i++){  
  8.             printf(“This is child process\n”);  
  9.         }  
  10.         exit(0);  
  11.     }else{  
  12.         //parent process  
  13.         wait();  
  14.         for(i=1; i<=8; i++){  
  15.             printf(“This is parent process\n”);  
  16.         }  
  17.     }  
  18.   
  19.     printf(“step2 after fork() !!\n\n”);  
  20. }  

 

输出:

 

图片 9

      见到这时的屏幕输出就很有规律了!

      其实wait() 函数还有1个功能, 就是可以接收1个
pid_t(在unistd.h内,其实就是Int啦) 指针类型参数,  
给这个参数赋上子进程退出前的系统pid值

     流程图:

  图片 10

 

 

 

 

 

2. exec 函数组

 

      需要注意的是exec并不是1个函数, 其实它只是一组函数的统称,
它包括下面6个函数:

     

[cpp] view
plain copy

 

  1. #include <unistd.h>  
  2.   
  3. int execl(const char *path, const char *arg, …);  
  4.   
  5. int execlp(const char *file, const char *arg, …);  
  6.   
  7. int execle(const char *path, const char *arg, …, char *const envp[]);  
  8.   
  9. int execv(const char *path, char *const argv[]);  
  10.   
  11. int execvp(const char *file, char *const argv[]);  
  12.   
  13. int execve(const char *path, char *const argv[], char *const envp[]);  

 

       可以见到这6个函数名字不同, 而且他们用于接受的参数也不同.

       实际上他们的功能都是差不多的,
因为要用于接受不同的参数所以要用不同的名字区分它们,
毕竟c语言没有函数重载的功能嘛..  

 

       但是实际上它们的命名是有规律的:

       exec[l or v][p][e]

       exec函数里的参数可以分成3个部分,      执行文件部分,    
命令参数部分,   环境变量部分.

        例如我要执行1个命令   ls -l /home/gateman  

        执行文件部分就是  “/usr/bin/ls”

        命令参赛部分就是 “ls”,”-l”,”/home/gateman”,NULL             
见到是以ls开头 每1个空格都必须分开成2个部分, 而且以NULL结尾的啊.

        环境变量部分, 这是1个数组,最后的元素必须是NULL 例如  char *
env[] = {“PATH=/home/gateman”, “USER=lei”, “STATUS=testing”, NULL};

        

        好了说下命名规则:

        e后续,  参数必须带环境变量部分,  
环境变零部分参数会成为执行exec函数期间的环境变量, 比较少用

        l 后续,   命令参数部分必须以”,” 相隔, 最后1个命令参数必须是NULL

        v 后续,  
命令参数部分必须是1个以NULL结尾的字符串指针数组的头部指针.        
例如char * pstr就是1个字符串的指针, char * pstr[] 就是数组了,
分别指向各个字符串.

        p后续,   执行文件部分可以不带路径, exec函数会在$PATH中找

 

          

         还有1个注意的是, exec函数会取代执行它的进程,  也就是说,
一旦exec函数执行成功, 它就不会返回了, 进程结束.  
但是如果exec函数执行失败, 它会返回失败的信息, 
而且进程继续执行后面的代码!

 

       通常exec会放在fork() 函数的子进程部分, 来替代子进程执行啦,
执行成功后子程序就会消失,  但是执行失败的话,
必须用exit()函数来让子进程退出!

       下面是各个例子:

 

实例1:

2.1  execv 函数

 

[cpp] view
plain copy

 

  1. int childpid;  
  2. int i;  
  3.   
  4. if (fork() == 0){  
  5.     //child process  
  6.     char * execv_str[] = {“echo”, “executed by execv”,NULL};  
  7.     if (execv(“/usr/bin/echo”,execv_str) <0 ){  
  8.         perror(“error on exec”);  
  9.         exit(0);  
  10.     }  
  11. }else{  
  12.     //parent process  
  13.     wait(&childpid);  
  14.     printf(“execv done\n\n”);  
  15. }  

注意字符串指针数组的定义和赋值

 

 

 

2.2  execvp 函数

 

 

[cpp] view
plain copy

 

  1. if (fork() == 0){  
  2.     //child process  
  3.     char * execvp_str[] = {“echo”, “executed by execvp”,”>>”, “~/abc.txt”,NULL};  
  4.     if (execvp(“echo”,execvp_str) <0 ){  
  5.         perror(“error on exec”);  
  6.         exit(0);  
  7.     }  
  8. }else{  
  9.     //parent process  
  10.     wait(&childpid);  
  11.     printf(“execvp done\n\n”);  
  12. }  

 

#include <stdio.h>

2.3 execve 函数

 

[cpp] view
plain copy

 

  1. if (fork() == 0){  
  2.     //child process  
  3.     char * execve_str[] = {“env”,NULL};  
  4.     char * env[] = {“PATH=/tmp”, “USER=lei”, “STATUS=testing”, NULL};  
  5.     if (execve(“/usr/bin/env”,execve_str,env) <0 ){  
  6.         perror(“error on exec”);  
  7.         exit(0);  
  8.     }  
  9. }else{  
  10.     //parent process  
  11.     wait(&childpid);  
  12.     printf(“execve done\n\n”);  
  13. }  

 

 

#include <stdlib.h>

2.4 execl 函数

 

[cpp] view
plain copy

 

  1. if (fork() == 0){  
  2.     //child process  
  3.     if (execl(“/usr/bin/echo”,”echo”,”executed by execl” ,NULL) <0 ){  
  4.         perror(“error on exec”);  
  5.         exit(0);  
  6.     }  
  7. }else{  
  8.     //parent process  
  9.     wait(&childpid);  
  10.     printf(“execv done\n\n”);  
  11. }  

 

#include <unistd.h>

2.5 execlp 函数

 

[cpp] view
plain copy

 

  1. if (fork() == 0){  
  2.     //child process  
  3.     if (execlp(“echo”,”echo”,”executed by execlp” ,NULL) <0 ){  
  4.         perror(“error on exec”);  
  5.         exit(0);  
  6.     }  
  7. }else{  
  8.     //parent process  
  9.     wait(&childpid);  
  10.     printf(“execlp done\n\n”);  
  11. }  

 

 

2.6 execle 函数

 

[cpp] view
plain copy

 

  1. if (fork() == 0){  
  2.     //child process  
  3.     char * env[] = {“PATH=/home/gateman”, “USER=lei”, “STATUS=testing”, NULL};  
  4.     if (execle(“/usr/bin/env”,”env”,NULL,env) <0){  
  5.         perror(“error on exec”);  
  6.         exit(0);  
  7.     }  
  8. }else{  
  9.     //parent process  
  10.     wait(&childpid);  
  11.     printf(“execle done\n\n”);  
  12. }  

 

 

 输出:

图片 11

 

 

int glob = 6;

3. fork() 和exec 函数与system()函数比较

     见到上面execvp函数的输出. 你会发现 exec函数只是系统调用,
它是不支持管线处理的

     而system()函数是支持的.   他的内部会自动fork()
1个子进程,但是效率没有fork() 和 exec配合使用好.

 

     但是exec 支持执行脚本. 
所以不需要管线处理的命令或者脚本可以利用fork() 和 exec函数来执行.

 

 

char buf[] = “a write to
stdout\n”;

4. 利用 fwrite() ,fork() 和exec 函数 替代system()函数.

 

     上面讲过了, 虽然exec函数不支持管线, 而且命令参数复杂,
但是它支持执行脚本啊, 所以我们可以使用fwrite将
有管线处理的命令写入1个脚本中, 然后利用exec函数来执行这个脚本.

     下面会编写1个base_exec(char *) 函数, 接收1个字符串参数,  
然后执行它.

 

      这里只会大概写出这个函数的逻辑步骤:

      1. 利用getuid函数获得当前的pid,  然后利用pid获得当前唯一的文件名,
避免因为相同程序同时执行发生冲突!

      2.  利用fwrite函数在 /tmp/下面  建立1个上面文件名的脚本文件.    
因为/tmp/ 任何用户都可以读写啊

     3.  把命令参数写入脚本

     4. 利用fork() 和 exec() 执行这个脚本

     5. 有需要的话当exec执行完, 记录日志.

 

     下面就是i代码:

头文件:

base_exec.h

 

[cpp] view
plain copy

 

  1. #ifndef __BASE_EXEC_H_  
  2. #define __BASE_EXEC_H_  
  3.   
  4.     int base_exec(char *) ;  
  5.   
  6. #endif /* BASE_EXEC_H_ */  

源文件:

 

base_exec.c

 

[cpp] view
plain copy

 

  1. #include “base_exec.h”  
  2. #include <stdio.h>  
  3. #include <stdlib.h>  
  4. #include <string.h>  
  5. #include <unistd.h>  
  6. #include <time.h>  
  7.   
  8. #define LOGFILE “/home/gateman/logs/c_exec.log”  
  9.   
  10. int base_exec(char * pcmd){  
  11.     FILE * pf;  
  12.     pid_t pid = getpid();  
  13.     char pfilename[20];  
  14.     sprintf(pfilename, “/tmp/base_exec%d.sh”,pid);  
  15.   
  16.     pf=fopen(pfilename,”w”); //w is overwrite, a is add  
  17.     if (NULL == pf){  
  18.         printf(“fail to open the file base_exec.sh!!!\n”);  
  19.         return -1;  
  20.     }  
  21.   
  22.     fwrite(“#!/bin/bash\n”, 12, 1, pf);  
  23.     fwrite(pcmd, strlen(pcmd),1, pf);  
  24.     fwrite(“\n”, 1,1, pf);  
  25.   
  26.     fclose(pf);  
  27.   
  28.     if (fork() ==0 ){  
  29.         //child processj  
  30.         char * execv_str[] = {“bash”, pfilename, NULL};  
  31.         if (execv(“/bin/bash”,execv_str) < 0){  
  32.             perror(“fail to execv”);  
  33.             exit(-1);  
  34.         }  
  35.     }else{  
  36.         //current process  
  37.         wait();  
  38.         pf=fopen(LOGFILE,”a”);  
  39.   
  40.         if (NULL == pf){  
  41.             printf(“fail to open the logfile !!!\n”);  
  42.             return -1;  
  43.         }  
  44.         time_t t;  
  45.         struct tm * ptm;  
  46.         time(&t);  
  47.         ptm  = gmtime(&t);  
  48.         char cstr[24];  
  49.         sprintf (cstr, “time: %4d-%02d-%02d %02d:%02d:%02d\n”, 1900+ptm->tm_year,ptm->tm_mon,ptm->tm_mday,ptm->tm_hour,ptm->tm_min,ptm->tm_sec);  
  50.         fwrite(cstr, strlen(cstr),1, pf);  
  51.   
  52.         int uid = getuid();  
  53.         sprintf(cstr, “uid: %d\ncommand:\n”,uid);  
  54.         fwrite(cstr, strlen(cstr),1, pf);  
  55.   
  56.         fwrite(pcmd, strlen(pcmd),1, pf);  
  57.         fwrite(“\n\n\n”, 3,1, pf);  
  58.         fclose(pf);  
  59.         remove(pfilename);  
  60.         return 0;  
  61.     }  
  62.     return 0;  
  63. }  

 

int main()

{

int
var;

int
pid;

 

var =
88;

 

if(write(STDOUT_FILENO,buf,sizeof(buf) -1) != sizeof(buf)
-1)

{

perror(“fail
to write”);

return
-1;

}

 

printf(“before fork\n”);

 

if((pid =
fork()) < 0)

{

perror(“fail
to fork”);

return
-1;

}else 

if(pid ==
0)

{

glob
++;

var
++;

}else{

sleep(2);

}

 

printf(“pid
= %d,glob = %d,var = %d\n”,getpid(),glob,var);

exit(0);

}

 

运行结果:

图片 12

从上面可以看出,因为子进程和父进程拥有独立的物理内存空间,所以当子进程对拷贝来的数据做修改的时候,并没有影响到父进程。

 

注意:

       
1.一般来说,fork之后父进程先执行还是子进程先执行是不确定的。这取决于内核所使用的调度算法。

        

       
2.从上面可以看到两次的运行结果不一样。我们知道write函数是不带缓存的。因为在fork之前调用write,所以其数据写到标准输出一次。但是,标准
I/O库是带缓存的。如果标准输出连到终端设备,则它是行缓存的,否则它是全缓存的。当以交互方式运行该程序时,只得到printf输出的行一次,其原因是标准输出缓存由新行符刷新。但是当将标准输出重新定向到一个文件时,却得到printf输出行两次。其原因是,在fork之前调用了printf一次,当调用fork时,该行数据仍在缓存中,然后在父进程数据空间复制到子进程中时,该缓存数据也被复制到子进程中。于是那时父、子进程各自有了带该行内容的缓存。在exit之前的第二个printf将其数据添加到现存的缓存中。当每个进程终止时,其缓存中的内容被写到相应文件中。

 

 

实例 2:

 

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

 

int glob = 6;

 

int main()

{

int
var;

int
pid;

 

var =
88;

 

printf(“father:\n”);

printf(“&glob = %p\n”,&glob);

printf(“&var
= %p\n”,&var);

printf(“__________________________________\n”);

 

if((pid =
fork()) < 0)

{

perror(“fail
to fork”);

return
-1;

 

}else 

if(pid ==
0)

{

printf(“child var value not change\n:”);

printf(“&glob = %p\n”,&glob);

printf(“&var
= %p\n”,&var);

 

glob
++;

var
++;

 

printf(“__________________________________\n”);

printf(“child var value change:\n”);

printf(“&glob = %p\n”,&glob);

printf(“&var
= %p\n”,&var);

}

 

exit(0);

}

 

运行结果如下:

图片 13

   从上面可以看出,根据copy-on-write的思想,在子进程中,改变父进程的数据时,会先
复制父进程的数据修然后再改,从而达到子进程对数据的修改不影响父进程。但是我们发现,复制的前后,其值的地址都是一样的。为什么呢?子进程拷贝的时候也拷贝了父进程的虚拟内存”页”,这样他们的虚拟地址都一样,但是对应不同的物理内存空间。

 

二、copy-on-write工作原理

 

   
假设进程A创建子进程B,之后进程A和进程B共享A的地址空间,同时该地址空间中的页面全部被标识为写保护。此时B若写address的页面,由于写保护的原因会引起写异常,在异常处理中,内核将address所在的那个写保护页面复制为新的页面,让B的address页表项指向该新的页面,新页面可写。而A的address页表项依然指向那个写保护的页面。然后当B在访问address时就会直接访问新的页面了,不会在访问到哪个写保护的页面。当A试图写address所在的页面时,由于写保护的原因此时也会引起异常,在异常处理中,内核如果发现该页面只有一个拥有进程,此种情况下也就是A,则直接对该页面取消写保护,此后当A再访问address时不会在有写保护错误了。如果此时A又创建子进程C,则该address所在的页面又被设置为写保护,拥有进程A和C,同时其他页面例如PAGEX依然维持写保护,只是拥有进程A、B和C。如果此时A访问PAGEX,则异常处理会创建一个新页面并将PAGEX中的内容复制到该页面,同时A相应
的pte指向该新页面。如果此时C也访问PAGEX,也会复制新页面并且让C对应的pte指向新页面。如果B再访问PAGEX,则由于此时PAGEX只有一个拥有进程B,故不再复制新页面,而是直接取消该页面的写保护,由于B的pte本来就是直接指向该页面,所以无需要在做其它工作。

 

三、exit和_exit

 

(1)正常终止:

    (a)在main函数内执行return语句。这等效于调用exit。

    (b)调用exit函数

    (c)调用_exit系统调用函数

 

(2)异常终止:

    (a)调用abort。它产生SIGABRT信号,所以是一种异常终止的一种特列。

   
(b)当进程接收到某个信号时。例如,进程越出其地址空间访问存储单元,或者除以0,内核就会为该进程产生相应的信号。

 

注意:不管进程如何终止,最后都会执行内核中的同一段代码。这段代码为相应进程关闭所有打开描述符,释放它所使用的存储器等。

 

 

exit和_exit的不同

图片 14

_exit()函数的作用最为简单:直接进程停止运行,清除其使用的内存空间,并销毁其在内核中的各种数据结构;

 

exit()函数与_exit()函数最大的区别就在于exit()函数在调用exit系统调用之前要检查文件的打开情况,把文件缓冲区中的内容写回文件,就是”清理I/O”缓冲。

 

探究 1._exit()

 

//_exit(0)   exit(0)  return 0

图片 15

编译运行结果:

图片 16

从上面我们看到,test.txt的内容为空.为什么呢?因为标准I/O函数是带缓存的,进行fputs的时候是先向缓存中写的,只有当缓存满的时候才会刷新的缓冲区的。从以上我们发现,当进程退出时,执行_exit()函数并没有刷新缓冲区的数据,而是直接终止进程的。

 

探究2.exit()

图片 17

编译运行结果:
图片 18

从上面我们可以看到,当exit()函数结束进程的时候,对缓存进行了处理,把缓存的数据写到了磁盘文件中。

 

探究3.return

 

由读者自己完成,其实return语句用在main函数中,和exit是一样的。但是我们知道,return返回的值是给调用者的,它代表着一个函数的结束。

 

四、exec函数族

 

exec.c  调用exec其中的一个函数; gcc exec.c -o exec; ./exec

exec函数族提供了一种在进程中启动另一个程序执行的方法。它可以根据指定的文件名或目录名找到可执行文件,并用它来取代原调用进程的数据段、代码段、和堆栈段。在执行完之后,原调用进程的内容除了进程号外,其他全部都被替换了。

 

可执行文件既可以是二进制文件,也可以是任何Linux下可执行的脚本文件。

 

何时使用?

 

当进程认为自己不能再为系统和用户做任何贡献了就可以调用exec函数族中的函数,让自己执行新的程序。

当前目录: 可执行程序A    B(1,2,3)     

如果某个进程想同时执行另一个程序,它就可以调用fork函数创建子进程,然后在子进程中调用任何一个exec函数。这样看起来就好像通过执行应用程序而产生了一个新进程一样。

 

execl(“./B”,”B”,”1″,”2″,”3″,NULL);

char *const envp[] = {“B”,”1″,”2″,”3″,NULL}

 

execv(“./B”,envp);

图片 19

图片 20
图片 21

注意:不管file,第一个参数必须是可执行文件的名字

 

可执行文件查找方式

表中的前四个函数的查找方式都是指定完整的文件目录路劲,而最后两个函数(以p结尾的函数)可以只给出文件名,系统会自动从环境变量”$PATH”所包含的路径中进行查找。

 

参数表传递方式

两种方式:一个一个列举和将所有参数通过指针数组传递

一函数名的第5个字母按来区分,字母”l”(list)的表示一个一个列举方式;字母”v”(vector)的表示将所有参数构造成指针数组传递,其语法为char
*const argv[]

 

环境变量的使用

exec函数族可以默认使用系统的环境变量,也可以传入指定的环境变量。这里,以”e”(Envirment)结尾的两个函数execle、execve就可以在envp[]中传递当前进程所使用的环境变量。

 

使用的区别

可执行文件查找方式

参数表传递方式

环境变量的使用

图片 22

案例一execl

 

#include <stdio.h>

#include <unistd.h>

 

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

{

printf(“start to execl.\n”);

if(execl(“/bin/ls”,”ls”,NULL) < 0)

{

perror(“Fail
to execl”);

return
-1;

}

printf(“end
of execl.\n”);

 

return
0;

}

 

运行结果如下:

图片 23

案例二、execlp

#include <stdio.h>

#include <unistd.h>

 

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

{

printf(“start to execl.\n”);

if(execlp(“ls”,”ls”,”-l”,NULL) < 0)

{

perror(“Fail
to execl”);

return
-1;

}

printf(“end
of execl.\n”);

 

return
0;

}

 

运行结果:

图片 24

案例三、execle

 

#include <stdio.h>

#include <stdlib.h>

 

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

{

if(getenv(“B”) == NULL)

{

printf(“fail
to getenv B.\n”);

}else{

printf(“env
B = %s.\n”,getenv(“B”));

}

 

if(getenv(“C”) == NULL)

{

printf(“fail
to getenv C.\n”);

}else{

printf(“env
C = %s.\n”,getenv(“C”));

}

 

if(getenv(“PATH”) == NULL)

{

printf(“fail
to getenv PATH.\n”);

 

}else{

printf(“env
PATH = %s.\n”,getenv(“PATH”));

}

return
0;

}

 

运行结果:

图片 25

#include <unistd.h>

 

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

{

printf(“start to execle.\n”);

char *
const envp[] = {“B=hello”,NULL};

 

if(execle(“./A.out”,”A.out”,NULL,envp) < 0)

{

perror(“Fail
to execl”);

return
-1;

}

 

printf(“end
of execl.\n”);

 

return
0;

}

 

运行结果:

图片 26

案例四:execv

 

#include <stdio.h>

#include <unistd.h>

#include <errno.h>

#include <stdlib.h>

 

int main()

{

char *
const arg[] = {“ps”, “-ef”, NULL};

//if
(execl(“/bin/ps”, “ps”, “-ef”, NULL) < 0)

if
(execv(“/bin/ps” ,arg) < 0)

{

perror(“execl”);

exit(-1);

}

 

while
(1);

 

return
0;

}

 

 

五、进程的创建vfork()函数

       

     vfork与fork一样都创建一个子进程,但是它并不将父进程的地址空完全复制到子进程中,因为子进程会立即调用exec(或exit)于是也就不会存、访该地址空间。不过在子进程调用exec或exit之前,它在父进程的空间中运行。

    

   
vfork和fork之间的另一个区别是:vfork保证子进程先运行,在它调用exec或exit之后
父进程才可能被调度运行。(如果在调用这两个函数之前子进程依赖于父进程的进一步动作,则会导致死锁)

 

探究1.vfork()

图片 27

编译运行:

图片 28

因为我们知道vfork保证子进程先运行,子进程运行结束后,父进程才开始运行。所以,第一次打印的是子进程的打印的信息,可以看到var值变成了89。子进程结束后,父进程运行,父进程首先打印fork调用返回给他pid的值(就是子进程pid)。以上我们可以看出,vfork创建的子进程和父进程运行的地址空间相同(子进程改变了var
值,父进程中的var值也进行了改变)。

 

注意:如果子进程中执行的是exec函数,那就是典型的fork的copy-on-wirte。

 

 

五、wait和waitpid

 

wait函数:调用该函数使进程阻塞,直到任一个子进程结束或者是该进程接收到一个信号为止。如果该进程没有子进程或者其子进程已经结束,wait函数会立即返回。

 

waitpid函数:功能和wait函数类似。可以指定等待某个子进程结束以及等待的方式(阻塞或非阻塞)。

wait函数

#include <sys/types.h>

#include <sys/waith.h>

 

pid_t  wait(int  *status);

 

函数参数:

 

status是一个整型指针,指向的对象用来保存子进程退出时的状态。

 

A.status若为空,表示忽略子进程退出时的状态

 

B.status若不为空,表示保存子进程退出时的状态

 

子进程的结束状态可由Linux中一些特定的宏来测定。

 

 

案例一、

 

#include <stdio.h>

#include <stdlib.h>

 

int main()

{

int
pid;

 

if((pid =
fork()) < 0)

{

perror(“Fail
 to fork”);

return
-1;

}else if(pid
== 0){

printf(“child exit now.\n”);

exit(0);

}else{

while(1);

}

 

exit(0);

}

 

运行结果:

图片 29

从以上可以看出,子进程正常退出时,处于僵尸态。这个时候子进程的pid,以及内核栈资源并没有释放,这样是不合理的,我们应该避免僵尸进程。如果父进程先退出呢,子进程又会怎样?

 

#include <stdio.h>

#include <stdlib.h>

 

int main()

{

int
pid;

 

if((pid =
fork()) < 0)

{

perror(“Fail
 to fork”);

return
-1;

}else if(pid
== 0){

printf(“child running now – pid : %d.\n”,getpid());

while(1);

}else{

getchar();

printf(“Father exit now – pid : %d.\n”,getpid());

exit(0);

}

 

}

图片 30

从上面可以看出,如果父进程先退出,则子进程的父进程的ID号变为1,也就是说当一个子进程的父进程退出时,这个子进程会被init进程自动收养。

 

案例二、利用wait等待回收处于僵尸态的子进程

 

#include <stdio.h>

#include <stdlib.h>

 

int main()

{

int
pid;

 

if((pid =
fork()) < 0)

{

perror(“Fail
 to fork”);

return
-1;

}else if(pid
== 0){

printf(“child runing now – pid : %d.\n”,getpid());

getchar();

printf(“child exiting now – pid : %d.\n”,getpid());

exit(0);

}else{

printf(“Father wait zombie now – pid : %d.\n”,getpid());

wait(NULL);

printf(“Father exiting now – pid : %d.\n”,getpid());

exit(0);

}

 

}

 

没有输入字符前:

图片 31

输入字符后:

图片 32

此时我们没有发现僵尸进程,当子进程退出时,父进程的wait回收了子进程未释放的资源。

 

案例三、获取进程退出时的状态

 

#include <stdio.h>

#include <stdlib.h>

 

int main()

{

int
pid;

int
status;

 

if((pid =
fork()) < 0)

{

perror(“Fail
to fork”);

exit(-1);

}else if(pid
== 0){

printf(“create child process : %d.\n”,getpid());

printf(“child process : %d calling exit(7).\n”,getpid());

exit(7);

}else{

 

if((pid =
fork()) < 0 ){

perror(“Fail
to fork”);

exit(-1);

}else if(pid
== 0){

printf(“create child process : %d.\n”,getpid());

while(1);

}else{

 

while((pid =
wait(&status)) != -1)

{

if(WIFEXITED(status))

{

printf(“child process %d is normal exit,the value is
%d.\n”,pid,WEXITSTATUS(status));

 

}else
if(WIFSIGNALED(status)){

printf(“child process %d is exit by signal,the signal num is
%d.\n”,pid,WTERMSIG(status));

}else{

printf(“Not
know.\n”);

}

}

}

}

 

printf(“All
child process is exit,father is exit.\n”);

exit(0);

}

图片 33

给进程15494发个信号

图片 34

程序运行结果:

图片 35

从以上探究可以知道,每当子进程结束后,wait函数就会返回哪个子进程结束的pid。如果没有子进程存在,wait函数就返回-1。

 

函数返回值:

成功:子进程的进程号

失败:-1

#include <sys/types.h>

#include <sys/wait.h>

 

pid_t      waitpid(pid_t  pid,int *status,int options);

 

参数:

 

1.在父进程中创建两个子进程(A   B)

2.A进程打印”child process %d exit”,调用exit(2),结束

3.B进程一直运行

 

注意:父进程调用while(waitpid(-1,&status,WUNTRACED)   != -1 )

图片 36

status:同wait

 

options:

 

WNOHANG,若由pid指定的子进程并不立即可用,则waitpid不阻塞,此时返回值为0

WUNTRACED,若某实现支持作业控制,则由pid指定的任一子进程状态已暂停,且其状态自暂停以来还没报告过,则返回其状态。

 

0:同wait,阻塞父进程,等待子进程退出。

 

返回值

正常:结束的子进程的进程号

使用选项WNOHANG且没有子进程结束时:0

调用出错:-1

 

案例一、

 

#include <stdio.h>

#include <stdlib.h>

 

int main()

{

int
pid;

int
status;

 

if((pid =
fork()) < 0)

{

perror(“Fail
to fork”);

exit(-1);

}else if(pid
== 0){

printf(“create child process : %d.\n”,getpid());

printf(“child process : %d calling exit(7).\n”,getpid());

exit(7);

}else{

 

if((pid =
fork()) < 0 ){

perror(“Fail
to fork”);

exit(-1);

}else if(pid
== 0){

printf(“create child process : %d.\n”,getpid());

while(1);

}else{

 

while((pid =
wait(&status)) != -1)

{

if(WIFEXITED(status))

{

printf(“child process %d is normal exit,the value is
%d.\n”,pid,WEXITSTATUS(status));

 

}else
if(WIFSIGNALED(status)){

printf(“child process %d is exit by signal,the signal num is
%d.\n”,pid,WTERMSIG(status));

}else{

printf(“Not
know.\n”);

}

}

}

}

 

printf(“All
child process is exit,father is exit.\n”);

exit(0);

}

 

 

程序运行结果:

图片 37

使用ps -aux结果

图片 38

从以上可以看出,子进程15783退出时,父进程并没有回收它的资源,此时可以看到它处于僵尸态。

由于父进程调用waitpid等待子进程15784退出,此时这个进程还没退出,看可以看到父进程处于可中断的睡眠状态。

 

我们给子进程15784发个信号,在看看结果

图片 39

程序运行结果:

图片 40

可以看到当waitpid指定等待的进程退出时,waitpid立即返回,此时父进程退出。

 

案例二、

 

#include <stdio.h>

#include <stdlib.h>

 

int main()

{

int
pid;

int
status;

 

if((pid =
fork()) < 0)

{

perror(“Fail
to fork”);

exit(-1);

}else if(pid
== 0){

printf(“create child process : %d.\n”,getpid());

printf(“child process : %d calling exit(7).\n”,getpid());

exit(7);

}else{

 

if((pid =
fork()) < 0 ){

perror(“Fail
to fork”);

exit(-1);

}else if(pid
== 0){

printf(“create child process : %d.\n”,getpid());

while(1);

}else{

sleep(2);

printf(“Father wait child %d exit.\n”,pid);

while((pid =
waitpid(pid,NULL,WNOHANG)))

{

printf(“The
process %d is exit.\n”,pid);

}

 

printf(“The
process %d is exit.\n”,pid);

}

}

 

exit(0);

}

图片 41

从上面探究我们可以看出,如果有子进程处于僵尸态,waitpid(pid,NULL,WNOHANG)立即处理后返回,如果没有子进程处于僵尸态,此时waitpid(pid,NULL,WNOHANG)也会立即返回,而不阻塞,此时返回值为0。

 

案例探究三、

 

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

 

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

{

int
pid;

int
status;

 

if((pid =
fork()) < 0)

{

perror(“Fail
to fork”);

exit(-1);

}else if(pid
== 0){

printf(“create child process : %d.\n”,getpid());

printf(“child process in proces group %d.\n”,getpgid(0));

printf(“child process : %d calling exit(7).\n”,getpid());

exit(7);

}else{

 

if((pid =
fork()) < 0 ){

perror(“Fail
to fork”);

exit(-1);

}else if(pid
== 0){

sleep(3);

printf(“create child process : %d.\n”,getpid());

setpgid(0,0); //让子进程属于以自己ID作为组的进程组

printf(“child process in proces group %d.\n”,getpgid(0));

printf(“child process : %d calling exit(6).\n”,getpid());

}else{

while(pid =
waitpid(0,NULL,0))

{

printf(“Father wait the process %d is exit.\n”,pid);

}

}

}

 

exit(0);

}

 

运行结果:

图片 42

当在父进中创建子进程时,父进程和子进程都在以父进程ID号为组的进程组。以上代码中,有一个子进程改变了自己所在的进程组.

此时waitpid(0,NULL,0);只能处理以父进程ID为组的进程组中的进程,可以看到第一个子进程结束后waitpid函数回收了它未释放的资源,而第二个子进程则处于僵尸态

图片 43

 

 

from:

相关文章