• 【Linux篇】第九篇——Linux下的进程控制

    ​进程创建

    ​fork函数

    ​写时拷贝

    ​进程终止

    ​进程退出三种场景

    ​进程常见退出方法

    ​进程等待

    ​进程等待的方法

    wait方法

    waitpid方法

    ​获取子进程的status

    ​阻塞等待和非阻塞等待

    ​进程程序替换

    ​原理

    ​替换函数

    ​简易shell的实现

    进程创建

    进程创建的最常见的两种场景:

    1.命令行启动命令(程序,指令等)

    2.通过程序自身fork出来子进程

    fork函数

    fork在前面有讲过，关于fork的用法可以去前面看看。在这里接着往下讲:

    fork创建子进程是以父进程为模板的，很多数据代码继承父进程，它从存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。

    fork函数也是一个系统调用接口，为当前进程创建子进程，子进程返回0，父进程返回子进程pid,出错返回-1。

    进程调用fork函数，内核需要做什么?

    • 给子进程分配内存空间,并为子进程创建PCB
    • 将父进程部分数据结构内容(还有代码和数据暂时共享)拷贝至子进程
    • 添加子进程到系统进程列表(运行队列)当中
    • fork返回，开始CPU调度器调度

    代码如下:

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. int main()
    6. {
    7.   pid_t ret = fork();
    8.   
    9.   if (ret < 0)
    10.   {
    11.     perror("fork");
    12.     return 1;
    13.   }
    14.   else if (ret == 0)// 子进程
    15.   {
    16.     printf("I am child-pid:%d, ppid:%d\n", getpid(), getppid());
    17.     sleep(1);
    18.   }
    19.   else if (ret > 0)// 父进程
    20.   {
    21.     printf("I am parent-pid:%d, ppid:%d\n", getpid(), getppid());
    22.     sleep(1);
    23.   }
    24.  
    25.   sleep(1);
    26.  
    27.   return 0;
    28. }

    运行结果 

    返回值:子进程返回0，父进程返回子进程id,出错返回-1

    为什么有两个返回值?

    fork之后会进入内核，fork函数的实现进行申请内存构建数据结构PCB,虚拟内存，页表，最后将当前进程设置为R状态，放置进调度列表中，此时进程已经创建成功,父子进程共享代码，fork函数的最后一个代码是返回一个值,return ret这个代码父子进程都会执行一次，所以会有两个返回值。

    在返回时，将函数的返回值返回给变量,发生了写时拷贝,一个变量名但是内容是不相同的,本质父子页表映射数据到了不同的内存区域。

    写时拷贝

    通常情况下，父子进程共享一份代码，且数据也是共享的，当任意一方试图写入更改数据，那么者一份便要以写时拷贝的方式各自私有一份副本，写时拷贝的识别，操作等是由OS完成。

    从图中可以看出,发生写时拷贝后，修改方将改变页表中对该份数据的映射关系,父子进程各自私有那一份数据，且权限由只读变成只写。

    在不写入的情况下，父子进程共享代码和数据:

    1. #include
    2. #include
    3. int main()
    4. {
    5.     const char *str = "hello Linux!\n";
    6.     fork();
    7.     while(1)
    8.     {
    9.         printf("pid:%d,ppid: %d,str: %s\n",getpid(),getppid(),str);
    10.         sleep(1);
    11.     }
    12.     return 0;
    13. }

    运行结果 

    可以看到代码每次执行两次，其实是两个进程在执行。其中，默认情况下，父子进程共享代码，但是数据是各自私有一份的。

    代码共享:所有代码共享，因为程序计数器的原因，一般都是从fork之后开始执行，那么为什么代码要共享?因为代码是不可以被修改的，所以各自私有浪费空间。为什么数据要私有一份？因为进程之间具有独立性，如果父进程正在执行，子进程将父进程的数据改了，那就影响到了父进程。

    fork常规用法

    • 一个父进程希望复制自己，使父子进程同时执行不同的代码段:父进程等待客户端请求，生成子进程来处理请求。
    • 一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数。

    fork调用失败的原因

    • 系统中有太多进程
    • 实际用户的进程数超过了限制

    问题分析

    1. 为什么代码是共享？

    代码是不能被修改的，各自私有是很浪费空间的，大多数情况下是共享的，但是在特殊情况下，代码也是会发生写时拷贝的,也就是进程的程序替换(后面详细讲)。

         2.写时拷贝的作用?

    • 可以减少空间浪费，在双方都不对数据或代码进行修改的情况下，各自私有一根数据和代码是浪费空间的。
    • 维护进程之间的独立性，虽然父子进程共享一份数据，但是父子中有一方对数据进行修改,那么就拷贝该份数据给修改方，改变修改方中页表对这份数据的映射关系，然后对数据进行修改，这样不管哪一方对数据进行修改都不会影响另一方，这样就做到了独立性。

        3.写时拷贝是对所有数据进行拷贝嘛?

    答案是否定的。如果没有修改的数据进行拷贝，那么这样还是会造成空间浪费的，没有被修改的数据还是可以共享的，我们只需要将修改的那份数据进行写时拷贝即可。

    进程终止

    进程退出三种场景

    • 代码运行完成，结果正确

    代码没有任何错误，且代码逻辑正确

    • 代码运行完成，结果不正确

    代码运行过程中没有任何错误，但是代码逻辑存在问题,导致结果不正确

    • 代码运行异常终止

    代码运行过程中发生了例一些异常终止的错误，如:野指针访问，除零错误等

    进程常见退出方法

    正常终止

    1.main函数返回退出码

    main函数退出的时候，return的返回值就是进程的退出码。0在函数的设计中,一般代表是正确而非0就是错误的。

    echo $?

    实例演示:

    1. int main()
    2. {
    3.   return 0;
    4. }

    运行结果 

     

    为什么main函数的return一般写成0？0在函数设计中，一般代表正确，非零代表出错。这里的return是给系统看，确认进程的执行结果是否正确，退出码可以人为的定义，也可以使用系统的错误码list，那么非零到底是什么意思?当程序运行失败的时候，我们最关心的是为什么失败?失败原因，计算机不擅长处理，擅长处理整数类型的数据,所以退出码都是整数类型的，但是我们人又擅长字符串的描述，所以就有错误码和字符串的映射；

    1. #include
    2. #include
    3. int main()
    4. {
    5.   for(int i=0;i<200;i++)
    6.   {
    7.     printf("%d:%s\n",i,strerror(i));
    8.   }
    9.   return 0;
    10. }

     2.调用exit函数

    exit:终止整个进程，任何地方调用，都会终止

    return:终止函数，如果是main函数return ,代表终止进程

    1. int main()
    2. {
    3.   cout << "12345";
    4.   sleep(3);
    5.   exit(0);// 退出进程前前会执行用户定义的清理函数，且刷新缓冲区
    6.   return 0;
    7. }

    运行结果

    调用exit函数，此时直接就讲进程终止了，并不会再去执行下面的语句了。

    3.调用_exit函数

    exit和_exit几乎一模一样，区别在于exit是库函数，_exit是系统调用，exit在退出程序时会刷新缓冲区,而_exit在退出时不会刷新缓冲区。

    会刷新缓冲区

    1. int main()
    2. {
    3.     cout<<"123";//写入缓冲区
    4.     exit();
    5. }

     不会刷新缓冲区

    1. int main()
    2. {
    3.     cout<<"123";//写入缓冲区
    4.     _exit();
    5. }

    示意图:

    异常终止 

    • ctrl+C终止前台进程

    • ctrl+C终止前台进程 

    站在OS角度，如何理解进程终止?

    进程终止的核心思想就是归还资源：

    1、"释放"曾经为了管理进程所维护的所有的数据结构对象。

    2、释放程序代码和数据占用的内存空间。

    3、取消曾经该进程的链接关系(比如和它和它的父进程之间的链接关系)

    上面提到了两个释放，所谓第一个释放不是真的把数据结构对象销毁，而是设置为不用状态，然后保存起来，如果不用的对象多了，就有一个"数据结构的池"

    第二个释放不是代码和数据清空，而是把内存设置为无效就可以了

    实际上我们每次申请空间是比较耗时的，由于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片并进而降低性能。 内存池则是在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是，使得内存分配效率得到提升。而数据结构池就是，当一个进程创建时有task_struct，mm_struct等各种数据结构变量，而我们在申请这些内存时，每次都要将这块内存强转为(task_struct*)，(mm_struct*)，这样时间效率肯定不好，所以就有一个数据结构池，这里面是一些无效的pcb以及mm_struct，他们处于一个废弃队列当中，当创建进程需要内存时，就将这里的内存提取出去。
     

    进程等待

    进程等待的必要性:

    • 子进程必须要比父进程先退出,否则会变成孤儿进程
    • 父进程必须读取子进程的退出状态，回收子进程的资源。如果父进程不读取子进程退出状态,还不会是子进程资源，那么子进程将处于僵死状态，会造成内存泄漏
    • 父进程派给子进程的任务完成的如何，得知子进程执行结果

    进程等待的方法

    wait方法

    wait函数原型:

    1. #include
    2. #include
    3. pid_t wait(int* status);

    返回值

    返回值有两种，一种是等待进程的pid,另一种就是-1，等待成功返回等待进程的pid,等待失败就返回-1

    参数

    status是一个输出型参数,可以通过传地址获得进程退出状态,如果不想关心进程退出状态，就传NULL

    实例演示

    让子进程先运行5s,然后退出进程,子进程由S状态变为Z状态,父进程等待子进程,回收子进程资源后，子进程变为Z状态变为X状态,10秒回父进程退出

    代码如下

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. int main()
    9. {
    10. 	pid_t ret= fork();
    11. 	if (ret< 0){
    12. 	  cerr << "fork error" << endl;
    13. 	}
    14. 	else if (ret== 0){
    15. 	  // child
    16. 	  int count = 5;
    17. 	  while (count){
    18. 		printf("child[%d]:I am running... count:%d\n", getpid(), count--);
    19. 		sleep(1);
    20. 	  }
    21. 	  exit(1);
    22. 	}
    23. 	// parent
    24. 	printf("father begins waiting...\n");
    25. 	sleep(10);
    26. 	pid_t id = wait(NULL);// 不关心子进程退出状态
    27. 	
    28. 	printf("father finish waiting...\n");
    29. 	if (id > 0){ 
    30. 	  printf("child success exited\n"); 
    31. 	} else{
    32. 	  printf("child exit failed\n"); 
    33. 	} 
    34. 	//父进程再活5秒 
    35. 	sleep(5);
    36. 	return 0;
    37. }
    38.

     命令行监控脚本如下

    1. while :; do ps axj | head -1 && ps axj | grep test | grep -v grep ; sleep 1; echo "############"; done
    2.

    运行结果

     

     子进程由S状态转变为Z状态

    父进程等待子进程，回收子进程资源后，子进程变为Z状态变为X状态

    waitpid方法

    函数原型如下

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

     函数返回值

    • 当正常返回的时候waitpid返回收集到的子进程的进程ID;
    • 如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集，则返回0；
    • 如果调用中出错，则返回-1，这时errno会被设置成相应的值以指示错误所在；

    参数

    • pid

    pid=-1时，可以等待任一个子进程,与wait等待

    pid>0时，等待和pid相同的ID的子进程

    • status 

    是一个输出型参数，不想关心进程退出状态就传NULL

    WIFEXITED(status):若为正常终止子进程返回的状态，则为真(查看进程是否是正常退出)

    WEXITSTATUS（status):若WIFEXITED非零,提取子进程退出码。(查看进程的退出码)

    •  options

    WNOHANG:若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束,则返回该子进程的ID(可以进行基于阻塞等待的轮询访问)

    0:阻塞等待(等待期间父进程不执行任何操作)

    实例演示

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7.  int main()
    8.  {
    9.   pid_t id=fork();
    10.   if(id==0)
    11.   {
    12.       int cnt=3;
    13.       while(cnt)
    14.       {
    15.         printf("child[%d] is running:cnt is:%d\n",getpid(),cnt);
    16.        cnt--;
    17.         sleep(1);
    18.       }
    19.      //exit(0);
    20.       exit(11);                                                                                                                                                                                                 
    21.     }
    22.     printf("father wait begin!\n");
    23.    int status=0;
    24.     pid_t ret=waitpid(id,&status,0);
    25.     if(ret>0)
    26.     {
    27.       printf("father wait:%d,success,status exit code:%d.status exit signal:%d\n",ret,(status>>8)&0xFF,status&0x7F);
    28.     }
    29.     else{
    30.       printf("father wait failed!\n");
    31.     }
    32.   
    33.   }

    运行结果

    正常跑完，结果正确

     正常跑完，结果不正确

    异常终止

    获取子进程的status

    • wait和waitpid中都有一个status参数,该参数是一个输出型参数,由操作系统来填充
    • 如果该参数给NULL,那么代表不关心子进程的退出信息 

     status的几种状态:(我们只研究status的低16位)

     看图可以知道，低7位代表的是终止信号，第8位时core dump标志，高八位是进程退出码（只有正常退出是这个退出码才有意义）
    status的0-6位和8-15位有不同的意义。我们要先读取低7位的内容，如果是0，说明进程正常退出，那就获取高8位的内容，也就是进程退出码；如果不是0，那就说明进程是异常退出，此时不需要获取高八位的内容，此时的退出码是没有意义的。
    实例演示

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. int main()
    9. {
    10. 	pid_t ret = fork();
    11. 	if (ret < 0){
    12. 	  cerr << "fork error" << endl;
    13. 	}
    14. 	else if (ret == 0){
    15. 	  // child
    16. 	  int count = 5;
    17. 	  while (count){
    18. 	    printf("child[%d]:I am running... count:%d\n", getpid(), count--);
    19. 	    sleep(1);
    20. 	  }
    21. 	
    22. 	  exit(1);
    23. 	}
    24. 	// parent
    25. 	printf("father begins waiting...\n");
    26. 	
    27. 	int status;
    28. 	pid_t id = wait(&status);// 从status中获取子进程退出的状态信息
    29. 	printf("father finish waiting...\n");
    30. 	
    31. 	if (id > 0 && (status&0x7f) == 0){
    32. 	  // 正常退出
    33. 	  printf("child success exited, exit code is:%d\n", (status>>8)&0xff);
    34. 	}
    35. 	else if (id > 0){
    36. 	  // 异常退出
    37. 	  printf("child exit failed,core dump is:%d,exit singal is:%d\n", (status&(1<<7)), status&0x7f);
    38. 	}
    39. 	else{
    40. 	  printf("father wait failed\n");
    41. 	}
    42. 	if (id > 0){ 
    43. 	  printf("child success exited\n"); 
    44. 	} else{
    45. 	  printf("child exit failed\n"); 
    46. 	} 
    47.  	return 0;
    48. }

     代码运行结果如下

    阻塞等待和非阻塞等待

    操控者： 操作系统
    阻塞的本质： 父进程从运行队列放入到了等待队列，也就是把父进程的PCB由R状态变成S状态，这段时间不可被CPU调度器调度
    等待结束的本质： 父进程从等待队列放入到了运行队列，也就是把父进程的PCB由S状态变成R状态，可以由CPU调度器调度

    • 阻塞等待： 父进程一直等待子进程退出，期间不干任何事情

           实例1：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. int main()
    9. {
    10.   pid_t id = fork();
    11.   if (id < 0){
    12.     cerr << "fork error" << endl;
    13.   }
    14.   else if (id == 0){
    15.     // child
    16.     int count = 5;
    17.     while (count){
    18.       printf("child[%d]:I am running... count:%d\n", getpid(), count--);
    19.       sleep(1);
    20.     }
    21.     exit(0);
    22.   }
    23.   
    24.   // 阻塞等待
    25.   // parent
    26.   printf("father begins waiting...\n");
    27.   int status;
    28.   pid_t ret = waitpid(id, &status, 0);
    29.   printf("father finish waiting...\n");
    30.  
    31.   if (id > 0 && WIFEXITED(status)){
    32.     // 正常退出
    33.     printf("child success exited, exit code is:%d\n", WEXITSTATUS(status));
    34.   }
    35.   else if (id > 0){
    36.     // 异常退出
    37.     printf("child exit failed,core dump is:%d,exit singal is:%d\n", (status&(1<<7)), status&0x7f);
    38.   }
    39.   else{
    40.     printf("father wait failed\n");
    41.   }
    42. }
    • 非阻塞等待： 父进程不断检测子进程的退出状态，期间会干其他事情（基于阻塞的轮询等待）
      实例2
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. int main()
    9. {
    10.   pid_t id = fork();
    11.   if (id < 0){
    12.     cerr << "fork error" << endl;
    13.   }
    14.   else if (id == 0){
    15.     // child
    16.     int count = 5;
    17.     while (count){
    18.       printf("child[%d]:I am running... count:%d\n", getpid(), count--);
    19.       sleep(1);
    20.     }
    21.     exit(0);
    22.   }
    23.   // 基于阻塞的轮询等待
    24.   // parent
    25.   while (1){
    26.     int status;
    27.     pid_t ret = waitpid(-1, &status, WNOHANG);
    28.     if (ret == 0){
    29.       // 子进程还未结束
    30.       printf("father is running...\n");
    31.       sleep(1);
    32.     }
    33.     else if (ret > 0){
    34.       // 子进程退出
    35.       if (WIFEXITED(status)){
    36.         // 正常退出
    37.         printf("child success exited, exit code is:%d\n", WEXITSTATUS(status));
    38.       }
    39.       else{
    40.         // 异常退出
    41.         printf("child exited error,exit singal is:%d", status&0x7f);
    42.       }
    43.       break;
    44.     }
    45.     else{
    46.       printf("wait child failed\n");
    47.       break;
    48.     }
    49.   }
    50.   
    51. }
    52.

    进程程序替换

    fork创建子进程后一般会有两种行为:

    • 想让子进程执行父进程的一部分代码(可以理解为子承父业)
    • 想让子进程执行和父进程完全不同的代码，也就是程序替换(可以理解为儿子创业)

    原理

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

    问题: 

    1.程序替换的本质是什么?

    把磁盘中的程序的代码和数据用加载器加载进特定的进程的上下文,底层用到了exec系列的程序替换了函数。

    2.程序替换后，有没有新进程被创建?

    没有。因为进程替换前后，没有创建新的PCB，虚拟内存和页表等数据结构,也就是进程的这些数据结构没有发生变化，进程替换只是对物理内存中的数据和代码进行了修改,前后进程的ID没有发生改变,所以程序替换不创建新进程.

    3. 子进程发生程序替换后,代码和数据都发生写时拷贝嘛?

    由于进程替换会把新程序的代码和数据加载到特定的进程,为了让父子进程之间具有独立性,修改的代码和数据都要发生写时拷贝,这样才不会影响父进程的数据和代码。

    替换函数

    其中有六种以exec开头的函数,统称exec函数:操作系统其实只提供了第六个系统调用接口，其他五个都是由第六个系统调用接口封装出来的。

    1. #include 
    2. extern char **environ;
    3. int execl(const char *path, const char *arg, ...);//...是可变参数
    4. int execlp(const char *file, const char *arg, ...);
    5. int execle(const char *path, const char *arg, ...,char *const envp[]);
    6. int execv(const char *path, char *const argv[]);
    7. int execvp(const char *file, char *const argv[]);
    8. int execve(const char *path, char *const argv[], char *const envp[]);

    函数返回值:只要exec*返回，就一定调用失败了，调用成功不需要有返回值检测。

    函数参数:

    • path:用来替换的程序所在的路径
    • file:程序名
    • arg,...:列表的形式传参
    • arg[]:数组的形式传参
    • envp[]:自己维护的环境变量

    函数名解释:

    • l(list):表示参数采用列表
    • v(vector):参数用数组
    • p(path):有p自动搜索环境变量PATH
    • e(env):表示自己维护环境变量
    1. void myfun(char *arg1,char *arg2,char *arg3);//列表式传参
    2. myfun(a1,a2,a3);//list
    3. void myfun(char *arg[]);//非列表式的传参
    4. char *arg[] = {a1,a2,a3};
    5. myfun(arg);

    参数命名中有I的需要一个一个进行传参，有v的需要将参数放入数组，通过数组传参，有p的第一个参数是file,而不带p的第一个参数是path,有p自动去环境变量PATH中搜索;传参时可以直接传想要使用的命令,不需要传路径，会自动搜索,只需要告诉执行的命令是谁

    函数的使用方法

    函数名参数格式是否带路径是否使用当前环境变量
    execl列表是是
    execlp列表否是
    execle列表是否，自己组装环境变量
    execv数组是是
    execvp数组否是
    execve数组是否，自己组装环境变量

     execl

    第一个参数是你要执行哪个程序(需要带路径),因为执行程序需要知道你在哪，你是谁,第二个是要执行的程序名，命令行怎么执行,传入什么选项,你就可以在这里直接按照顺序填写参数,命令行上怎么写，这里就怎么写，这种传参方式叫做list方式,最后必须以NULL结尾,告知execl传参结束。 

    1. #include
    2. #include
    3. int main()
    4. {
    5.   execl("/usr/bin/ps","ps","-e","-l","-f",NULL);
    6.   return 0;
    7. }

     运行结果

    第一个参数代表你要执行谁，第二个参数是你在命令行怎么调用执行，在后面的参数中你就怎么传递。

    再看一组程序

    1. #include
    2. #include
    3. int main()
    4. {
    5.     printf("begin............................\n");
    6.     execl("/usr/bin/ls","ls","-a","-l","-i",NULL);
    7.     printf("hello world\n");
    8.     printf("hello world\n");
    9.     printf("hello world\n");
    10.     printf("hello world\n");
    11.     return 0;
    12. }

     运行结果

    ./test是自己写的可执行程序,./test变成了进程,代码执行到execl，进行程序替换，用ls进程的代码和数据替换test进程的代码和数据,执行ls进程。

    注意:这些函数如果调用成功则加载新的程序从启动代码开始执行，不再返回。如果调用出错则返回-1，所以exec函数只有出错的返回值而没有成功的返回值，所以exec系列函数是没有返回值的，如果返回了,或者执行了后续的代码，一定是程序替换错了。

    举个例子，加深理解

    1. #include
    2. #include
    3. int main()
    4. {
    5.  printf("begin...........\n");
    6.  execl("/usr/bi/ps","ls","-a","-l","-i",NULL);
    7.  printf("hello world!\n");
    8.  printf("hello world!\n);
    9.  printf("hello world!\n");
    10.  printf("hello world!\n");
    11.  return 0;
    12. }

     运行结果

     可以让子进程去干程序替换这件事情:

    1. #include
    2. #include
    3. #include
    4. int main()
    5. {
    6.     //execl("/usr/bin/ls", "ls",_"-a","-l"，"-i"，NULL);
    7. 	//execl("/usr/bin/top" , "top" ,NULL);
    8.     pid_t id = fork();
    9.     if(id<0)
    10.     {
    11.         perror("fork");
    12.         return 1;
    13.     }
    14.     else if(id == 0)
    15.     {
    16.         //child
    17.         printf("i am a child , pid:%d, ppid: %d\n",getpid(),getppid());
    18.         execlp("ls","ls","-al",NULL);
    19.         printf("hello world!\n);
    20.         exit(1);
    21.     }
    22.     //father
    23.     int status = 0;
    24.     pid_t ret = waitpid(id,&status,0);
    25.     if(ret > 0)
    26.     {
    27.         printf("wait success!\n");
    28.       //  printf("exit code: %d,exit status: %d\n",(status>>8)&0xFF,status & 0x7F);
    29.     }
    30.     else{
    31.         printf("wait failed!\n");
    32.     }
    33.     return 0;    
    34. }

     这里子进程进行了程序替换，退出的进程其实就是ls程序

     exec系列函数的理解

    软件被加载进内存，需要加载器，一个软件加载到内存就成了进程，首先软件先运行起来变成进程，然后进程调用exec系列函数，就可以完成加载到内存的过程，exec可以理解成一种特殊的加载器.

     execv

    传参以数组进行传参

    1. #include
    2. #include
    3. int main()
    4. {
    5.     printf("begin............................\n");
    6.     char *arg[] = {"ls","-a","-l","-i",NULL};
    7.     execv("/usr/bin/ls",arg);
    8.     printf("you should running here\n");
    9.     return 0;
    10. }

     

    execvp 

    带v以及带p，参数用数组传，带p说明第一个参数不需要传路径，它会自动的去环境变量PATH里面去找可执行程序,所以传命令名字就行。

    1. #include
    2. #include
    3. int main()
    4. {
    5.     printf("begin............................\n");
    6.     char *arg[] = {"ls","-a","-l","-i",NULL};
    7.     execvp("ls",arg);
    8.     printf("you should running here\n");
    9.     return 0;
    10. }

    execlp 

    带l以及带p，参数用列表形式传，带p说明第一个参数不需要传路径，传命令名字就行。

    1. #include
    2. #include
    3. int main()
    4. {
    5.     printf("begin............................\n");
    6.     execlp("ls","ls","-a","-l","-i",NULL);
    7.     printf("you should running here\n");
    8.     return 0;
    9. }

    elecle 

    带l和带e的，带e表示自己维护环境变量，传入默认的或者自定义的环境变量给目标可执行程序。

    在说明elecle函数之前，我门先想一个问题:

    exec系列函数能调用系统程序，那么他能调用自己的程序嘛?答案是可以的。

    1. #include
    2. int main()
    3. {
    4.     int i = 0;
    5.     int sum = 0;
    6.     for(;i<=100;i++)
    7.     {
    8.         sum+=i;
    9.     }
    10.     printf("result[1~100] sum is:%d\n",sum);
    11.     return 0;
    12. }

    Makefile的编写：

    makefile默认只生成一个可执行程序，默认是自顶向下扫描makefile文件遇到的第一个目标

    输入make bin命令 ，默认就生成bin

    1. .PHONY:all
    2. all:mytest mycmd
    3. mytest:Test.c
    4.     gcc -o $@ $^  
    5. mycmd:mycmd.c
    6.     gcc -o $@ $^
    7. .PHONY:clean
    8. clean:
    9.     rm mytest mycmd

     我们在Test.c中使用程序替换execl函数去执行我们写的程序：

    1. #include
    2. #include
    3. int main()
    4. {
    5.     printf("begin............................\n");
    6.     execl("./mycmd","./mycmd",NULL);
    7.     return 0;
    8. }

     可以看到我们成功的通过exec系列函数调用自己写的程序：

    上面说的都是为了说明execle系统调用所做的铺垫，下面我们再来看execle：

    我们在mycmd.c中获取一个环境变量myenv，而这个程序它本身是没有myenv这个环境变量的，所以我们就可以通过execle函数给我们写的程序将环境变量传过去：

    1. #include
    2. #include
    3. #include
    4. int main()
    5. {
    6.     char *env[] = {"myenv = you_can_see_me!",NULL};//自定义环境变量
    7.     printf("begin............................\n");
    8.     execle("./mycmd","./mycmd",NULL,env);//调用该函数并将自定义的环境变量数据传给目标程序
    9.     return 0;
    10. }
    1. #include
    2. #include
    3. int main()
    4. {
    5.     int i = 0;
    6.     int sum = 0;
    7.     for(;i<=100;i++)
    8.     {
    9.         sum+=i;
    10.     }
    11.     printf("result[1~100] sum is:%d\n",sum);
    12.     printf("myenv: %s\n",getenv("myenv"));
    13.     return 0;
    14. }

     我们运行mytest，发现完成的程序替换，而且将环境变量也传过去了。

    man查看exec系列函数：

     我们发现execve是和上面的函数分开的，本质上是因为，execve是最底层的系统调用，其他都是去调用它去完成的：

     实际中，我们可以fork出子进程，让子进程去进行程序替换，替父进程完成事情：

    1. #include
    2. #include
    3. #include
    4. int main()
    5. {
    6.     pid_t id = fork();
    7.     if(id<0)
    8.     {
    9.         perror("fork error\n");
    10.         return 1;
    11.     }
    12.     if(id == 0)
    13.     {
    14.         //child
    15.         execl("usr/bin/ls","ls","-a","-l","-i",NULL);
    16.         //如果返回则替换失败
    17.         exit(-1);
    18.     }
    19.     
    20.     pid_t ret = waitpid(id,NULL,0);
    21.     if(ret > 0)
    22.     {
    23.         printf("wait success,cmd exit\n");
    24.     }
    25.     return 0;
    26. }

    父进程正常执行自己要干的事情，因为替换的是子进程，进程是有独立性的，所以，父进程是不受影响的！ 

    简易shell的实现

    要写一个shell,需要循环以下过程:

    1.获取命令行

    2.解析命令行

    3.建立一个子进程(fork)

    4.替换子进程(execvp)

    5.父进程等待子进程退出(waitpid)

    我们发现shell运行原理就是用户执行命令，shell解释器创建子进程去执行命令,子进程将执行结构告诉shell,最后再反馈给用户，其实就是给上面的程序套上一层循环去创建子进程去执行命令:

    1. #include
    2. #include
    3. #include
    4. int main()
    5. {
    6.     while(1)
    7.     {
    8.         pid_t id = fork();
    9.         if(id<0)
    10.         {
    11.             perror("fork error\n");
    12.             return 1;
    13.         }
    14.         if(id == 0)
    15.         {
    16.             //child
    17.             execl("usr/bin/ls","ls","-a","-l","-i",NULL);
    18.             //如果返回则替换失败
    19.             exit(-1);
    20.         }
    21.  
    22.         pid_t ret = waitpid(id,NULL,0);
    23.         if(ret > 0)
    24.         {
    25.             printf("wait success,cmd exit\n");
    26.         }
    27.     }
    28.     return 0;
    29. }

    下面我们来实现我们的myshell.c，首先我们登录主机后，会打印命令提示符(用户名@主机名 当前目录)提示符，这里我们为了简单，就直接打印一个主机名:

    const char* cmd_line = "[temp@VM-0-3-centos myshell]#";

    然后我们需要做的就是数据读取，C语言有一个fgets函数，我们可以这样读取数据：

    fgets(cmd,SIZE,stdin);

     cmd是保存输入命令的一个数组，大小自己决定即可，size是读取的字符个数，stream是从哪里读，这里需要注意的是，我们读取结束后最后一个字符是\n，所以需要将它置为\0

    cmd[strlen(cmd)-1] = '\0';//标准输入会输入\n，将\n改为\0

    接下来就要进行字符串数据分析，怎么分析呢？我们首先要把输入的字符串以空格为标志进行分割，然后放进一个字符指针数组，不了解strtok函数的可以去了解一下：

    1. //字符串(命令行数据分析)
    2. char* args[NUM];
    3. args[0] = strtok(cmd," ");//字符串分割
    4. int i = 1;
    5. do{
    6.      rgs[i] = strtok(NULL," ");
    7.      if(args[i] == NULL)
    8.      {
    9.            break;
    10.      }
    11.      ++i;
    12. }while(1);

     然后就是创建子进程进行执行命令，子进程通过调用程序替换函数去执行命令，那么我们想一下我们用哪个函数呢？我们的命令是用数组存起来的，所以需要带v，那么就用execvp，并且不用传路径，传命令名就好，会自动去环境变量PATH里找：

    1. pid_t id = fork();
    2. if(id < 0)
    3. {
    4.      perror("fork error!\n");
    5.      continue;
    6. }
    7.  //4.执行非内置命令
    8. if(id == 0)
    9. {
    10.      //child
    11.      execvp(args[0],args);
    12.      exit(1);//替换失败了就直接退出
    13. }
    14. int status = 0;
    15. pid_t ret = waitpid(id,&status,0);
    16. if(ret>0)
    17. {
    18.     printf("status code :%d\n",(status>>8)&0xff);
    19. }

     代码实现如下:

    1. #include
    2. #include
    3. #include
    4. #include
    5. #define SIZE 256
    6. #define NUM 16
    7. int main()
    8. {
    9.     char cmd[SIZE];//保存命令
    10.     const char* cmd_line = "[temp@VM-0-3-centos ~]#";
    11.     while(1)
    12.     {
    13.         cmd[0] = 0;//清空数据
    14.         //memset(cmd,'\0',sizeof(cmd));
    15.         printf("%s",cmd_line);
    16.         //数据读取
    17.         fgets(cmd,SIZE,stdin);
    18.         //printf("%s",cmd);
    19.         cmd[strlen(cmd)-1] = '\0';//标准输入会输入\n，将\n改为\0
    20.         
    21.         //字符串(命令行数据分析)
    22.         char* args[NUM];
    23.         args[0] = strtok(cmd," ");//字符串分割
    24.         int i = 1;
    25.         do{
    26.             args[i] = strtok(NULL," ");
    27.             if(args[i] == NULL)
    28.             {
    29.                 break;
    30.             }
    31.             ++i;
    32.         }while(1);
    33. 		//shell内的函数调用，内置命令
    34.         pid_t id = fork();
    35.         if(id < 0)
    36.         {
    37.             perror("fork error!\n");
    38.             continue;
    39.         }
    40.         //4.执行非内置命令
    41.         if(id == 0)
    42.         {
    43.             //child
    44.             execvp(args[0],args);
    45.             exit(1);//替换失败了就直接退出
    46.         }
    47.         int status = 0;
    48.         pid_t ret = waitpid(id,&status,0);
    49.         if(ret>0)
    50.         {
    51.             printf("status code :%d\n",(status>>8)&0xff);
    52.         }
    53.     }
    54.     return 0;
    55. }

     上面的代码只是支持非内置命令，内置命令不可以，比如cd：

    我们期望改的是父进程shell的当前路径，这里则是修改的是子进程的当前路径，子进程干完事就退出了，所以不能创建子进程执行cd，也不能让父进程通过程序替换去执行cd，因为执行了父进程会影响，所以需要系统接口来完成命令的执行。

    如果想要支持cd命令，就需要在创建子进程前判断命令：

    1. if(strcmp( args[0]，"cd" ) == 0 && chdir(args[1])== 0)//chdir修改当前路径
    2. {
    3.     continue;
    4. }

     执行结果

     最终代码

    1. #include
    2. #include
    3. #include
    4. #include
    5. #define SIZE 256
    6. #define NUM 16
    7. int main()
    8. {
    9.     char cmd[SIZE];//保存命令
    10.     const char* cmd_line = "[temp@VM-0-3-centos ~]#";
    11.     while(1)
    12.     {
    13.         cmd[0] = 0;//清空数据
    14.         //memset(cmd,'\0',sizeof(cmd));
    15.         printf("%s",cmd_line);
    16.         //数据读取
    17.         fgets(cmd,SIZE,stdin);
    18.         //printf("%s",cmd);
    19.         cmd[strlen(cmd)-1] = '\0';//标准输入会输入\n，将\n改为\0
    20.         
    21.         //字符串(命令行数据分析)
    22.         char* args[NUM];
    23.         args[0] = strtok(cmd," ");//字符串分割
    24.         int i = 1;
    25.         do{
    26.             args[i] = strtok(NULL," ");
    27.             if(args[i] == NULL)
    28.             {
    29.                 break;
    30.             }
    31.             ++i;
    32.         }while(1);
    33.         //3.判断命令
    34.         if(strcmp( args[0],"cd" ) == 0 && chdir(args[1])== 0)//chdir修改当前路径
    35.         {
    36.             continue;
    37.         }
    38. 		//shell内的函数调用，内置命令
    39.         pid_t id = fork();
    40.         if(id < 0)
    41.         {
    42.             perror("fork error!\n");
    43.             continue;
    44.         }
    45.         //4.执行非内置命令
    46.         if(id == 0)
    47.         {
    48.             //child
    49.             execvp(args[0],args);
    50.             exit(1);//替换失败了就直接退出
    51.         }
    52.         int status = 0;
    53.         pid_t ret = waitpid(id,&status,0);
    54.         if(ret>0)
    55.         {
    56.             printf("status code :%d\n",(status>>8)&0xff);
    57.         }
    58.     }
    59.     return 0;
    60. }

  • 相关阅读:
    @JSONField注解
    C++结合OpenCV进行图像处理与分类
    22-08-29 西安 JUC（02）线程安全集合类、 juc强大的辅助类
    shouldComponentUpdate 是做什么的？
    idea的output输出乱码的问题
    【Buildroot】记一次编译出错gzip: popt-1.16.tar.gz: not in gzip format--更改br里面的默认下载地址
    基于SSM的毕业论文答辩系统
    大数据学习1.1-Centos8网络配置
    基于阴阳对算法的无人机航迹规划-附代码
    数据结构-顺序表学习资料
  • 原文地址：https://blog.csdn.net/m0_58367586/article/details/126272121