【Linux】进程控制 (万字）

小灰灰 2024-04-20 06:02 100阅读 0赞

> **?Linux：进程控制**
> 
> --------------------
> 
>  *  **博客主页：**[一起去看日落吗][Link 1]
>  *  **分享博主的在Linux中学习到的知识和遇到的问题**
>  *  **`博主的能力有限，出现错误希望大家不吝赐教`**
>  *  **分享给大家一句我很喜欢的话：** 看似不起波澜的日复一日，一定会在某一天让你看见坚持的意义，祝我们都能在鸡零狗碎里找到闪闪的快乐???。
> 
> --------------------
> 
> ![在这里插入图片描述][0c3f31bc6bb5460689d5e339f5299830.jpeg_pic_center]

? ? ?

--------------------

#### 目录 ####

*  ?1. 进程创建
 *   *  ?1.1 回忆fork
     *  ?1.2 fork函数的返回值
     *  ?1.3 写时拷贝
     *  ?1.4 fork常规用法
     *  ?1.5 fork调用失败的原因
 *  ?2. 进程终止
 *   *  ?2.1 进程退出的三种场景
     *  ?2.2 进程常见退出方法
 *  ?3. 进程等待
 *   *  ?3.1 进程等待的必要性
     *  ?3.2 进程等待的方法
     *   *  ?3.2.1 wait方法
         *  ?3.2.1 waitpid方法
     *  ?3.3 获取子进程status
 *  ?4. 进程替换
 *   *  ?4.1 为什么要进程替换
     *  ?4.2 替换原理
     *  ?4.3 替换函数
 *  ?5. 实现mini\_shell
 *   *  ?5.1 打印提示行
     *  ?5.2 获取命令行
     *  ?5.3 解析命令行
     *  ?5.4 fork创建子进程；替换子进程
     *  ?5.5 内建命令
     *  ?5.6 mini\_shell完整代码

## ?1. 进程创建 ##

**现阶段我们知道进程创建有如下两种方式：**

*  命令行启动命令 (程序、指令等)。
 *  通过程序自身，fork 的子进程。

### ?1.1 回忆fork ###

在linux中fork函数时非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。

#include <unistd.h>
    pid_t fork(void);
    返回值：自进程中返回0，父进程返回子进程id，出错返回-1

**进程调用fork，当控制转移到内核中的fork代码后，内核做：**

*  分配新的内存块和内核数据结构给子进程
 *  将父进程部分数据结构内容拷贝至子进程
 *  添加子进程到系统进程列表当中
 *  fork返回，开始调度器调度

> **现在我们知道，创建一个进程，内核会为它分配新的内存块加载代码和数据，创建各种内核数据结构包括进程控制块PCB、地址空间、页表、构建映射关系；将父进程部分数据结构内容拷贝至子进程；添加子进程到系统进程列表(运行队列)当中；fork返回，开始调度器调度。**

![在这里插入图片描述][970091ed1ad542fba6c9771a0b2d4e46.png]

当一个进程调用fork之后，就有两个二进制代码相同的进程。而且它们都运行到相同的地方。但每个进程都将可以  
开始它们自己的旅程，看如下程序。

#include <unistd.h>
    pid_t fork(void);
    返回值：自进程中返回0，父进程返回子进程id，出错返回-1
    int main( void )
    {
        
    	pid_t pid;
    	printf("Before: pid is %d\n", getpid());
    	if ( (pid=fork()) == -1 )perror("fork()"),exit(1);
    	printf("After:pid is %d, fork return %d\n", getpid(), pid);
    	sleep(1);
    	return 0;
    }
    
    
    
    运行结果：
    [root@localhost linux]# ./a.out
    Before: pid is 43676
    After:pid is 43676, fork return 43677
    After:pid is 43677, fork return 0

这里看到了三行输出，一行before，两行after。进程43676先打印before消息，然后它有打印after。另一个after消息有43677打印的。注意到进程43677没有打印before，为什么呢？

**如下图所示:**

![在这里插入图片描述][cece1dc521eb49d5a3b63a447e59b1d5.png]

所以，fork之前父进程独立执行，fork之后，父子两个执行流分别执行。注意，**fork之后，谁先执行完全由调度器决定。**

--------------------

### ?1.2 fork函数的返回值 ###

**观察如下代码运行后共创建了多少个子进程，他们之间的关系是什么？**  
![请添加图片描述][93ebd736b9c04625acb9d6cf8305d356.png]

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

`运行结果`  
![在这里插入图片描述][06227cf23c65424f827b4dbf76ea72f2.png_pic_center]

> **这里共创建了 4 个子进程，其中 11095 fork 之后，创建了 11096 进程，最后 11096 和 11095 会再 fork 11097 和 11098。这里就算是 11098 进程，对于 test.c 中所有的代码都是共享的，只不过不会执行它以上的代码，其中 11098 进程是通过程序计数器 epi 指针知道自己该执行哪行代码的。**

`一般不会让父子进程做同样的事情`  
![请添加图片描述][3bd7657d8dd04c7f8d39657a47ffd666.png]

#include<stdio.h>
    #include<unistd.h>                                                                                                            
    #include<sys/types.h> 
    
    int main()
    {
        
       const char* str = "hello byh";
       pid_t ret = fork();
       if(ret == 0)
       {
        
         while(1)
         {
        
           printf("%d\n",ret);
           printf("%p\n",&ret);
           printf("child,ppid: %d, pid: %d, str: %s\n",getppid(),getpid(),str);
           sleep(1);
         }
         return 0;
       }
       else if (ret > 0)
       {
        
         while(1)
         {
        
     
           printf("%d\n",ret);
           printf("%p\n",&ret);
           printf("child,ppid: %d, pid: %d, str: %s\n",getppid(),getpid(),str);
           sleep(1);
         }
       }
       else{
        
         perror("fork");
       }
       return 0;
     }

`运行代码`  
![请添加图片描述][228364346f2345eeab3c753e0beec0fb.png]

> **子进程创建之后，父子进程是共享代码的，我们认定 return 是代码，是和父子进程共享的代码，所以当我们父进程 return 时，这里的子进程也要 return，所以说这里的父子进程会 return 2 个值。**

> **这里 pid\_t ret = fork()，父进程调用 fork，在 return 时，子进程已经创建出来了，那么父进程就 return 子进程的 pid 来初始化 ret 局部变量，随后子进程就 return 0 ，此时必定是通过写时拷贝来完成数据的各自私有，虽然父子进程的 &ret 是一样的，但是物理内存一定是两块不同的空间。 当我们理解了为啥同一个变量，却可以是两个不同的值后，再看 fork 为啥会有两个返回值时就有了新的理解角度。**

**注意不是 fork 创建子进程，并写时拷贝，而是 fork 创建子进程之后，父子谁先写入谁就写时拷贝，这里发生写时拷贝的原因是父子进程 return 的值用于初始化局部变量 ret 了。**

*  一 ：父子进程会使 fork return 2 个值。
 *  二 (`较为准确`)：返回时发生了`写时拷贝`。

**写时拷贝的价值就是保证父子进程的独立性。**

--------------------

### ?1.3 写时拷贝 ###

**通常，父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。**

`具体见下图:`

![在这里插入图片描述][d84ca348e6724d7da83a760e6b652d0e.png]

在父/子修改数据时，会发生缺页中断：OS再开辟一段空间，把数据拷贝过来(写时拷贝)，重新建立映射关系；父子分开，更改读写权限。这时候再进行写操作。这样保证了父子进程的独立性。

**为什么存在写时拷贝?**

*  写时拷贝是为了保证父子进程的独立性。
 *  节省内存和系统资源，提高 fork 的效率，减少 fork 失败的概率。

**父子进程创建时，所有数据直接各自拷贝一份不行吗 ？？？**

**不使用写时拷贝也可以保证父子进程的独立性，为啥还要费劲使用写时拷贝?**

>  *  **所有的数据，父和子并不是都必须写入数据，`有可能它们仅仅需要读取，而此时的各自拷贝是没有意义的，而且会浪费内存和系统资源。`**
>  *  **fork 时，创建数据结构，如果还要将数据拷贝一份，`fork 的效率会降低`。**
>  *  **fork 本质就是向系统申请更多的内存资源，`资源申请多了，fork 有可能就会失败`。**

--------------------

### ?1.4 fork常规用法 ###

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

--------------------

### ?1.5 fork调用失败的原因 ###

**fork 是操作系统的接口，所以失败的原因一定是系统级别的原因。**

*  系统中已经存在太多的进程了。
 *  实际用户创建的进程超过了限制。

--------------------

## ?2. 进程终止 ##

### ?2.1 进程退出的三种场景 ###

*  **代码运行完毕，结果正确**
 *  **代码运行完毕，结果不正确**
 *  **代码异常终止**

**思考：为什么main函数总会return 0，意义何在？`是否可以是其他值呢？`**

![请添加图片描述][afc687297ec74660ba322c00765f64e9.png]

> **对于 main 函数的返回值，我们称之为进程退出码，它代表进程退出后，结果是否正确，通常进程退出码为`0 代表成功，!0 代表其它含义，如果你愿意你也可以 return 其它值。大部分情况下，main 函数跑完后，默认结果是正确的，所以以前返回的都是 0`。**

*  **查看最近一次进程退出时的退出码 `来衡量代码跑完对不对的`**

echo $?  查看退出码
    
    1.代码运行完毕，结果正确    - 0:  success
    2.代码运行完毕，结果不正确  - !0: failed → 为什么不正确？有多种可能，错误码对应字符串(strerror)
    3.代码异常终止			- 程序崩溃 → 退出码没有意义，return都不会跑(可以通过某种方式获得原因，进程等待详谈)

![请添加图片描述][dca33916a10042de8e3ebc9fff712fa1.png]

![在这里插入图片描述][561b9eb129b34471875fe91c57360c71.png_pic_center]

**演示 int 到 string 错误码之间的映射**

![请添加图片描述][445037f2d38e4449a026a69590d11be6.png]

`运行结果`

![在这里插入图片描述][ef54e297759d437a800d19fe6ea6fa0a.png_pic_center]

大部分情况下通常退出码是父进程关心的，因为父进程费了很大的劲把子进程创建出来干活，活干的怎么样，父进程得知道。野指针、/0、越界等都可能导致进程非正常结束，父进程也要关心这种情况，但此时退出码是无意义的。

--------------------

### ?2.2 进程常见退出方法 ###

*  **正常退出**

**main 函数 return**

![请添加图片描述][89568e20e7c740f5b673acd9f518e0e4.png]

**可以看到只有 main 函数的 return 才是结束进程，非 main 函数的 return 是结束函数。**

exit //终止进程

![在这里插入图片描述][fe3e8aae31b2489ca49fc330b26c3a9e.png_pic_center]

**`任何函数 exit，都表示直接终止进程`。**

![请添加图片描述][290fa8d265274ecbbf004fe27066e560.png]

*  **异常退出**

> **ctrl + c，信号终止**

*  **\_exit函数**

**这是系统提供的接口，它的原型同库里的 exit 函数，那么系统的 \_exit 和 库函数的 exit 有什么区别 ?**

>  *  **exit 在退出时同默认的 return，会进行后续资源处理，包括刷新缓冲区。**
>  *  **\_exit 在退出时，不会进行后续资源处理，直接终止进程。**

**exit最后也会调用\_exit**, 但在调用exit之前，还做了其他工作：

1.  执行用户通过 atexit或on\_exit定义的清理函数。
2.  关闭所有打开的流，所有的缓存数据均被写入
3.  调用\_exit

![在这里插入图片描述][f01e23d6719441f7adf1ca90bce3490b.png]

`实例：`

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退出**  
return是一种更常见的退出进程方法。执行return n等同于执行exit(n),因为调用main的运行时函数会将main的返回值当做 exit的参数。

--------------------

## ?3. 进程等待 ##

### ?3.1 进程等待的必要性 ###

*  **之前讲过，子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。**
 *  **另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力，因为谁也没有办法杀死一个已经死去的进程。**
 *  **最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。**
 *  **父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息**

--------------------

### ?3.2 进程等待的方法 ###

#### ?3.2.1 wait方法 ####

#include<sys/types.h>
    #include<sys/wait.h>
    
    pid_t wait(int* status);
    
    返回值：
    	成功则返回被等待进程的pid，失败则返回-1。
    参数：
    	输出型参数，获取子进程退出状态，不关心则可以设置为NULL。wait 的参数 int* status 会重点在下面的 waitpid 学习。

*  **测试用例一：**

`父进程等待子进程退出后，wait 取子进程的 pid。`

#include<stdio.h>
    #include<stdlib.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/wait.h>
    
    int main()
    {
        
        pid_t id = fork();
        if(id < 0)
        {
        
            perror("fork");
            return 1;
        }
        else if(id == 0)
        {
        
            int count = 5;
            while(count)
            {
        
                printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
                sleep(1);
            }                                                                                     
            printf("child quit...\n");
            exit(0);
        }
        else
        {
        
            printf("father is waiting...\n");
            pid_t ret = wait(NULL);
            printf("father is wait done, ret: %d\n", ret);
        }
        return 0;
    }

![在这里插入图片描述][a9d938acd59e4b20ba435216193a1d33.png_pic_center]

*  **测试用例二：**

`相比测试用例一，更直观的等待，进程从无到有，从有到无。`

#include<stdio.h>
    #include<stdlib.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/wait.h>
    
    int main()
    {
        
        pid_t id = fork();
        if(id < 0)
        {
        
            perror("fork");
            return 1;
        }
        else if(id == 0)
        {
        
            int count = 5;
            while(count)
            {
        
                printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
                sleep(1);
            }                                                                                     
            printf("child quit...\n");
            exit(0);
        }
        else
        {
        
            printf("father is waiting...\n");
            sleep(10);
            pid_t ret = wait(NULL);
            printf("father is wait done, ret: %d\n", ret);
            sleep(3);
            printf("father quit...\n");
        }
        return 0;
    }

`监控脚本`

while :; do ps ajx | head -1 && ps ajx | grep text | grep -v grep; sleep 1; echo "####################"; done

![在这里插入图片描述][5552d91e0d1248b985d844294f4c770d.png_pic_center]

![在这里插入图片描述][ece59d141b9949deb3181876e69d444c.png_pic_center]

*  **测试用例三：**

`fork 5 个子进程后，父进程依次等待，并回收僵尸进程。`

#include<stdio.h>                                                                                 
    #include<stdlib.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/wait.h>
    
    int main()
    {
        
        int i = 0;
        while(i < 5)
        {
            
            pid_t id = fork();
            if(id < 0)
            {
        
                perror("fork");
                return 1;
            } 
            if(id == 0)
            {
        
                int count = 5;
                while(count)
                {
        
                    printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
                    sleep(1);
                }                                                                                     
                printf("child quit...\n");
                exit(0);        
            }
            i++;
        }
        for(i = 0; i < 5; i++)
        {
         
            printf("father is waiting...\n");
            sleep(10);
            pid_t ret = wait(NULL);
            printf("father is wait done, ret: %d\n", ret);
            sleep(3);
            printf("father quit...\n");
        } 
        return 0;
    }

![在这里插入图片描述][8e5cbb35c0194ad389b62d48712ecfa2.png_pic_center]

> **父进程退出，子进程会被操作系统领养。那么这个僵尸进程是在被操作系统领养后立马回收，还是积累到一定的僵尸进程再回收，这是由操作系统的策略决定的，同时也跟当前操作系统的状态有关系，如果操作系统发现内存资源已经很紧张了，就会提前回收。**

--------------------

#### ?3.2.1 waitpid方法 ####

#include<sys/types.h>
    #include<sys/wait.h>
    
    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相等的子进程；
    		因为父进程返回的是子进程的pid，所以父进程就可以等待指定的子进程，等待本质是管理的一种方式；
    	status，
    		输出型参数，我们传了一个整数地址进去，最终通过指针解引用把期望的数据拿出来。与之对应的是实参传递给形参是输入型参数；
    		WIFEXITED(status)，查看进程是否正常退出，是则真，不是则假；
    		WEXITSTATUS(status)，查看进程退出码，需要WIFEXITED(status)返回true，WIFEXITED(status)正常退出则返回true；
    		WTERMSIG(status)，返回导致子进程终止的信号的编号，需要WIFSIGNALED(status)返回true，WIFSIGNALED(status)子进程被信号终止返回true；
    	options，
    		WNOHANG，若pid指定的子进程没有结束，则waitpid()函数返回0，本次不予以等待，需要我们再次等待；若非正常结束，则返回该子进程的ID；或者小于0，失败了。
    		0，阻塞式等待，同wait————子进程没退出、回收，父进程等待；

*  **如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退出信息。**
 *  **如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞。**
 *  **如果不存在该子进程，则立即出错返回。**

![在这里插入图片描述][b5ff79815bf44160af2116f9ad14bc06.png_pic_center]

--------------------

### ?3.3 获取子进程status ###

*  wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。
 *  如果传递NULL，表示不关心子进程的退出状态信息。
 *  否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
 *  status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）：

![在这里插入图片描述][148f2110c52441ea975351b963ca9be7.png]

**阻塞和非阻塞**

>  *  **关注的是程序在等待调用结果（消息，返回值）时的状态.**
>  *  **阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。**
>  *  **非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程。**

如果 waitpid 中的 options 传 WNOHANG ，那么等待方式就是非阻塞；如果传 0，那么等待方式就是阻塞。我们的代码都是单执行流，选择阻塞调用更简单。

`例子`

> **比如你的学习很差，所以打电话给楼上学习好的同学张三，说：张三，你下来，我请你吃个饭，然后你帮我复习一下。张三说：行，没问题，但是我在写代码，半个小时之后再来。一般一个班，学习好的人总是少数，所以你怕你电话一挂，有人又跟张三打电话求助，导致你不能及时复习，所以你又跟张三说：张三，你电话不要挂，你把电话放你旁边，我喜欢看你写代码的样子。然后你什么事都不做，就在那等待，直到张三下来。当然现实中很少有这种情况，但是这样的场景是存在的，一般是比较紧急的情况，比如你爸打电话让你做件事且告诉你不要挂电话。此时张三不下来，电话就不挂就类似于调用函数，这种等待方式就叫做阻塞等待。我们目前所调用的函数，全部是阻塞函数，不管是你自己写的、库里的、系统的，阻塞函数最典型的特征是调用 ➡ 执行 ➡返回 ➡ 结束，其中调用方始终在等待，什么事情都没做。**

*  **测试用例一：**

`父进程 fork 派生一个子进程干活，父进程通过 status 可以知道子进程把活做的怎么样。`

#include<stdio.h>
    #include<stdlib.h>                                                                            
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/wait.h>
    
    int main()
    {
        
        pid_t id = fork();
        if(id == 0)
        {
        
            int count = 5;
            while(count)
            {
        
                printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
                sleep(1);
            }                                                                                     
            printf("child quit...\n");
            exit(123);
        }
        //father
        int status = 0;
        pid_t ret = waitpid(-1, &status, 0);
        int code = (status >> 8) & 0xFF;
        printf("%d\n", status);
        printf("father wait done, ret: %d, exit code: %d\n", ret, code);
        if(code == 0)
        {
        
            printf("做好了\n");     
        }
        else  
        {
          
            printf("没做好\n");  
        }             
    
    	return 0;
    }

![请添加图片描述][4cb8e0de6ced42b49efdd28404a3a1f9.png]

父进程通过 waitpid 要拿子进程的退出码应该从哪里去取呢，明明子进程已经退出了。子进程是结束了，但是子进程的状态是僵尸，也就是说子进程的相关数据结构并没有被完全释放。当子进程退出时，进程的 task\_struct 里会被填入当前子进程退出时的退出码，所以 waitpid 拿到的 status 值是通过 task\_struct 拿到的。

*  **测试用例二：**

`针对测试用例二，父进程无非就是想知道子进程的工作完成的结果，那全局变量是否可以作为子进程退出码的设置，以此告知父进程子进程的退出码。`

#include<stdio.h>                                                                             
    #include<stdlib.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/wait.h>
    
    int code = 0;
    
    int main()
    {
        
        pid_t id = fork();
        if(id == 0)
        {
        
            int count = 5;
            while(count)
            {
        
                printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
                sleep(1);
            }                                                                                     
            printf("child quit...\n");
            code = 123;
            exit(0);
        }
        //father
        int status = 0;
        pid_t ret = waitpid(-1, &status, 0);
        printf("father wait done, ret: %d, exit code: %d\n", ret, code);
        if(code == 0)
        {
        
            printf("做好了\n");     
        }
        else
        {
        
            printf("没做好\n");
        }
    
    	return 0;
    }

![请添加图片描述][76a39c5954fd4c4c90fa8968e0115954.png]

很显然，不可以。这里对于全局变量，发生了写时拷贝，在进程地址空间里我们说过父子是具有独立性的，虽然变量是同一个，但实际上子进程或父进程所写的数据，它们都是无法看到彼此的，所以不可能让父进程拿到子进程的退出结果。

*  **测试用例三：**

`野指针异常终止`

#include<stdio.h>
    #include<stdlib.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/wait.h>
    
    int main()
    {
        
        pid_t id = fork();
        if(id == 0)
        {
        
            int count = 5;
            while(count)
            {
        
                printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
                sleep(1);
                //err
                int* p = 0x12345;                                                                 
                *p = 100;
            }                         
            printf("child quit...\n");
            exit(123);
        }              
        //father                            
        int status = 0;                     
        pid_t ret = waitpid(-1, &status, 0);
        int code = (status >> 8) & 0xFF;                                              
        int sig = status & 0x7F;//0111 1111                                           
        printf("father wait done, ret: %d, exit code: %d, sig: %d\n", ret, code, sig);
                 
        return 0;       
    }

![在这里插入图片描述][ad3e7083112b4178843cb882103dfc16.png_pic_center]

*  **测试用例四：**

`模拟异常终止 —— 使用kill -9信号亲手杀死子进程。`

#include<stdio.h>  
    #include<stdlib.h>  
    #include<unistd.h>  
    #include<sys/types.h>  
    #include<sys/wait.h>  
      
    int main()  
    {
          
        pid_t id = fork();  
        if(id == 0)  
        {
          
            int count = 50;                                                                       
            while(count)
            {
        
                printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
                sleep(1);
            }                                                                                     
            printf("child quit...\n");
            exit(123);
        }
        //father                        
        int status = 0;  
        pid_t ret = waitpid(-1, &status, 0);  
        int code = (status >> 8) & 0xFF;      
        int sig = status & 0x7F;//0111 1111   
        printf("father wait done, ret: %d, exit code: %d, sig: %d\n", ret, code, sig);  
                                                                                        
        return 0;                                                                       
    }

![在这里插入图片描述][305ccaf25aab4de292991366a28d5334.png_pic_center]

*  **测试用例五：**

`父进程完整的等待子进程的全过程。`

#include<stdio.h>                                                                             
    #include<stdlib.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/wait.h>
    
    int main()
    {
        
        pid_t id = fork();
        if(id == 0)
        {
        
            int count = 5;
            while(count)
            {
        
                printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
                //err
                //int* p = 0x12345;
                //*p = 100;
                sleep(1);
            }
            printf("child quit...\n");
            exit(123);
        }
        //father
        int status = 0;
        pid_t ret = waitpid(id, &status, 0);
        if(ret > 0)
        {
        
            printf("wait success!\n");
            if((status & 0x7F) == 0)
            {
        
                printf("process quit normal!\n");
                printf("exit code: %d\n", (status >> 8) & 0xFF);
            }
            else
            {
        
                printf("process quit error!\n");
                printf("sig: %d\n", status & 0x7F);
            }
        }
        
        return 0;
    }

![请添加图片描述][81b701862cf64cbca6bc2b6432254d33.png]

*  **测试用例六：**

`非阻塞等待`

#include<stdio.h>                                                                             
    #include<stdlib.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/wait.h>
    
    int main()
    {
        
        pid_t id = fork();
        if(id == 0)
        {
        
            int count = 3;
            while(count)
            {
        
                printf("child is running: %d, ppid: %d, pid: %d\n", count--, getppid(), getpid());
                //err
                //int* p = 0x12345;
                //*p = 100;
                sleep(1);
            }
            printf("child quit...\n");
            exit(123);
        }
    
        //father 非阻塞等待
        int status = 0;
        while(1)
        {
        
            pid_t ret = waitpid(id, &status, WNOHANG);
            if(ret == 0)
            {
        
                printf("wait next!\n");
                printf("father do other thing!\n");
            }
            else if(ret > 0)
            {
        
                printf("wait success, ret: %d, pid: %d\n", ret, WEXITSTATUS(status));
                break;
            }
            else
            {
        
                printf("wait failed!\n");
                break;
            }
        }
    
        //father 阻塞等待
        //int status = 0;
        //pid_t ret = waitpid(id, &status, 0);
        //if(ret > 0)
        //{
        
        //    printf("wait success!\n");
        //    if(WIFEXITED(status))
        //    {
        
        //        printf("normal quit!\n");
        //        printf("quit code: %d\n", WEXITSTATUS(status));
        //    }
        //    else
        //    {
        
        //        printf("process quit error!\n");
        //        printf("sig: %d\n", WTERMSIG(status));
        //    }
        //}
    
        return 0;
    }

![请添加图片描述][b8adf02de87b49678ae1f56f8063dedd.png]

--------------------

## ?4. 进程替换 ##

### ?4.1 为什么要进程替换 ###

**创建子进程的目的：**

*  执行父进程的部分代码。
 *  我们之前所写的代码都属于这种情况。
 *  执行其它程序的代码。
 *  不要父进程的代码和数据。所以我们要学习进程替换。

> **进程替换是为了子进程能够执行其它程序的代码；进程替换就是以写时拷贝的策略，让第三方进程的代码和数据替换到父进程的代码和数据，给子进程用，因为进程间具有独立性，所以不会影响父进程。以前我们说数据是可写的，代码是不可写的，现在看来，确实如此。但是接下来要把其它程序的代码通过进程替换放在内存里让子进程与之关联，此时就要给代码进行写时拷贝。99% 的情况是对数据进行写时拷贝，1% 的情况是代码依旧是只读，本质就是对父进程不可写，子进程后续调用某些系统调用，实际给子进程重新开辟空间把新进程的代码加载，不让子进程执行父进程的代码。**

--------------------

### ?4.2 替换原理 ###

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

![在这里插入图片描述][bc3c55a0582b4cedbc1ead3b623ab0ef.png]

--------------------

### ?4.3 替换函数 ###

`有6个以exec*开头的调用接口，执行函数替换 ——`

#include <unistd.h>
    
    int execl(const char *path, const char *arg, ...);
    int execv(const char *path, char *const argv[]);
    int execlp(const char *file, const char *arg, ...);
    int execvp(const char *file, char *const argv[]);
    int execle(const char *path, const char *arg, ...,char *const envp[]);
    int execve(const char *path, char *const argv[], char *const envp[]);

这些函数的功能都是一样的，如果用 C++ 去设计这样的接口，一定是重载。这里是使用 C 去设计的，函数名的命名也有区分。

![请添加图片描述][5ca02ed0598b44d68ce053c5452ef17a.png]

`在下文中会测试`

--------------------

**函数解释及使用：**

*  这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。
 *  如果调用出错则返回 -1。
 *  所以 exec 函数只有出错的返回值而没有成功的返回值。

**命名理解**  
这些函数原型看起来很容易混,但只要掌握了规律就很好记。

*  l(list) : 表示参数采用列表
 *  v(vector) : 参数用数组
 *  p(path) : 有p自动搜索环境变量PATH
 *  e(env) : 表示自己维护环境变量

--------------------

*  **测试用例一：**

![请添加图片描述][070bfae707c240f4bf1d45f34b51cbc2.png]

`单进程，父进程亲自干活。`

#include<stdio.h>  
    #include<unistd.h>
    
    int main()
    {
        
        printf("my process begin!\n");
        execl("/usr/bin/ls", "ls", "-a", "-l", "-i", NULL);
        printf("my process end!\n");                       
        return 0;                                          
    }

![在这里插入图片描述][4b4b503d050941b5931f24a2019e5c88.png_pic_center]

`多进程，父进程创建子进程干活。`

#include<stdio.h>  
    #include<stdlib.h>  
    #include<unistd.h>  
    #include<sys/types.h>  
    #include<sys/wait.h>  
      
    int main()  
    {
          
        pid_t id = fork();  
        if(id == 0)  
        {
          
            printf("I am child, pid: %d, ppid: %d\n", getpid(), getppid());  
            execl("/usr/bin/ls", "ls", "-a", "-l", "-i", NULL);                                 
            exit(1);  
        }                                                                                      
        //father                                                                               
        int status = 0;                                                                        
        pid_t ret = waitpid(id, &status, 0);                                                   
        if(ret > 0)                                                                            
        {
                                                                                              
            printf("child status -> sig: %d, code: %d\n", status & 0x7F, (status >> 8) & 0xFF);
        }                                                                                      
        else                                                                                   
        {
                                                                                              
            printf("wait error!\n");                                                           
        }                                                                                      
                                                                                               
        return 0;                                                                              
    }

![请添加图片描述][502ecd9cc89a4620a92d93b48e38e586.png]

**为什么图一没有输出 my process end ! && 图二的退出码是 0** ?

> **因为在这之前 execl 已经程序替换了，所以 execl 后面的代码已经不是当前进程的代码了，所以图二获取到的退出码 0 是 ls 的退出码。换言之，一旦程序替换，你到底执行正确与否是取决于 ls 程序。所以 exec 系列的函数不用考虑返回值，只要返回了，一定是这个函数调用或程序替换失败了。**

*  **测试用例二：**

![在这里插入图片描述][148a5a80cdf74362a97f415908c2e26c.png_pic_center]

`execv 与 execl 较为类似，它们的唯一差别是，如果需要传多个参数，那么：execl 是以可变参数的形式进行列表传参；execv 是以指针数组的形式传参。`

#include<stdio.h>
    #include<stdlib.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/wait.h>
    
    int main()
    {
        
        pid_t id = fork();
        if(id == 0)
        {
        
        	//const char* const my_argv[] = {"ls", "-l", "-a", "-i", NULL};//err,注意要与函数原型的参数类型匹配
            char* const my_argv[] = {
        "ls", "-l", "-a", "-i", NULL};                            
            printf("I am child, pid: %d, ppid: %d\n", getpid(), getppid());
            execv("/usr/bin/ls", my_argv);
            exit(1);
        }
        //father    
        int status = 0;
        pid_t ret = waitpid(id, &status, 0);
        if(ret > 0)
        {
        
            printf("child status -> sig: %d, code: %d\n", status & 0x7F, (status >> 8) & 0xFF);
        }
        else
        {
        
            printf("wait error!\n");
        }
    
        return 0;
    }

![请添加图片描述][0fe07c05b4b04c72a9b91003aa361f91.png]

*  **测试用例三：**

![请添加图片描述][236dbffd216a440b9cee67c97d7dc8d7.png]

`execlp 相比 execl 在命名上多了 1 个 p，且参数只有第 1 个不同：不同点在于 execlp 不需要带路径，execlp 在执行时，它会拿着你要执行的程序自动的在系统 PATH 环境变量中查找你要执行的目标程序。`

![请添加图片描述][0f029bf484da41b39e8370774e462f95.png]

> **带 p 的含义就是不用带路径，系统会自动搜索你要执行的程序，不带 p 则相反。所以你要执行哪个程序，背后的含义是 a) 你在哪 b) 你是谁。可见 execlp 就是 b，execl 就是 ab。当然这里的搜索默认只有系统的命令才能找到，如果需要执行自己的命令，需要提前把自己的命令与 `环境变量` 关联。**

--------------------

## ?5. 实现mini\_shell ##

**写一个shell 命令行解释器，需要循环以下过程**

*  打印提示行
 *  获取命令行
 *  解析命令行
 *  fork创建子进程；替换子进程
 *  父进程等待子进程退出

--------------------

### ?5.1 打印提示行 ###

\[用户名@主机名 路径\]提示符，这些都可以通过系统调用获取到，但是对于理解Linux意义不大，就直接写死了。

写进度条时候就知道，显示器的刷新策略就是行刷新，不想换行还要刷新，**可以调用fflush(stdout);**

--------------------

### ?5.2 获取命令行 ###

**注意，输入一整行，要用fgets。再这个字符串打印出来，发现多换了一次行，这是因为我们把回车也读入进command串儿中，需要把\\n处置0。**

//2.获取命令行
          fgets(command, NUM, stdin);
          //printf("echo %s\n", command);// ls -a -l\n\0
          command[strlen(command)-1] = 0;

--------------------

### ?5.3 解析命令行 ###

**解析字符串，要分割串，用strtok。传参给要解析的字符串、分隔符串儿，返回子串；第二次提取时，把还想提取的老串儿给NULL——**

**我们把子串儿都提取到char\*的指针数组argv中。**

//3.解析命令行字符串，argv[] - strtok
          const char* sep = " ";
          argv[0] = strtok(command, sep);
          int i = 1;
          while(argv[i] = strtok(NULL, sep))
          {
        
            i++;
          }
            
       	  if(strcmp(argv[0], "cd")==0)
          {
        
            if(argv[1])
              chdir(argv[1]);
            continue; //
          }

--------------------

### ?5.4 fork创建子进程；替换子进程 ###

**不能用当前进程直接替换，会把前面的解析代码覆盖掉，因此要创建子进程。同时，父进程需要等待子进程退出。这也就解释了为什么在bash上执行出错了，echo $? 就能拿到退出码，这是因为子进程的退出结果是可以wait拿到的**

--------------------

### ?5.5 内建命令 ###

wait我们发现，对于|管道和>重定向是无法处理的，因为当前代码没有组合设置，我们实现的其实是一个相当简陋的shell。然而震惊的是，我们 cd… 路径没有回退？！这是因为执行回退的是子进程，并非是父进程bash.

fork要执行的命令是第三方命令，对于cd，现在我们不想再执行第三方命令，**以内建命令方式运行(即不创建子进程，让父进程shell自己执行)，实际上相当于调用了自己的一个函数。更改当前进程路径，有一个系统调用接口chdir**

--------------------

### ?5.6 mini\_shell完整代码 ###

#include<stdio.h>
      #include<stdlib.h>
      #include<string.h>
      #include<sys/wait.h>
      #include<unistd.h>
      
      #define NUM 128                                                                                                                                             
      #define CMD_NUM 64
      
      int main()
      {
        
        char command[NUM];
        char* argv[CMD_NUM] = {
        NULL};//未设置就是NULL值
        for(;;)
        {
        
          command[0]=0;//这种方式可以做到，时间复杂度O(1)，清空字符串
          //1.打印提示符
          printf("[you-know-who@myhostname mydir]$ ");
          fflush(stdout); 
          
          //2.获取命令行
          fgets(command, NUM, stdin);
          //printf("echo %s\n", command);// ls -a -l\n\0
          command[strlen(command)-1] = 0;
          
          //3.解析命令行字符串，argv[] - strtok
          const char* sep = " ";
          argv[0] = strtok(command, sep);
          int i = 1;
          while(argv[i] = strtok(NULL, sep))
          {
        
            i++;
          }
            
       	  if(strcmp(argv[0], "cd")==0)
          {
        
            if(argv[1])
              chdir(argv[1]);
            continue; //
          }
      
          //5.执行第三方命令
          if(fork()==0)
          {
        
            //child
            execvp(argv[0], argv);
            exit(1);
          }
      
          waitpid(-1, NULL, 0);
        }
        return 0;
      }

--------------------

[Link 1]: https://blog.csdn.net/m0_60338933?type=blog
[0c3f31bc6bb5460689d5e339f5299830.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/f30f43f3362e47cab4798e359026f8b0.jpeg
[970091ed1ad542fba6c9771a0b2d4e46.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/f93820fd506d486b97d4db26fc2d9a28.png
[cece1dc521eb49d5a3b63a447e59b1d5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/eaaba382264842c289ef15b627b7c9b0.png
[93ebd736b9c04625acb9d6cf8305d356.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/048ddf48abae44728de09ebfc10ad97e.png
[06227cf23c65424f827b4dbf76ea72f2.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/34474e311f364ce6b03879fc56dc42d0.png
[3bd7657d8dd04c7f8d39657a47ffd666.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/f007ad4f28ce46f990d3888c0a64ccd5.png
[228364346f2345eeab3c753e0beec0fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/6e1267494dc5459dae9d1330a239d17e.png
[d84ca348e6724d7da83a760e6b652d0e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/9982a27dbefe4a3d9e4cf359effa224b.png
[afc687297ec74660ba322c00765f64e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/31a04cc730ea45bcb4a95bb1ee4ea3c0.png
[dca33916a10042de8e3ebc9fff712fa1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/112fa55e9b6748e3b95e17d6f5c724a1.png
[561b9eb129b34471875fe91c57360c71.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/86f1ff2eaf4d4ce9926d2ad8ad798e3c.png
[445037f2d38e4449a026a69590d11be6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/92d4c8ecdded4f5e86fe9e97d1bd3f3e.png
[ef54e297759d437a800d19fe6ea6fa0a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/74edde1e44e7457d9d4f1d0fde21bcb7.png
[89568e20e7c740f5b673acd9f518e0e4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/5d9d7db315eb4f3699088027e9e273d2.png
[fe3e8aae31b2489ca49fc330b26c3a9e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/17357ece95734660ba4e4250588c9ad6.png
[290fa8d265274ecbbf004fe27066e560.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/23aedc60d5b74d67aebb6e0ec560cf1c.png
[f01e23d6719441f7adf1ca90bce3490b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/c87484bd8915417391a832f4ef345839.png
[a9d938acd59e4b20ba435216193a1d33.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/ad60927f33bf489785e3d1844c93d38d.png
[5552d91e0d1248b985d844294f4c770d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/865839cfe26e4392b4cf5c5c280dd3f9.png
[ece59d141b9949deb3181876e69d444c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/4aa98fc834974172852647eac9623cad.png
[8e5cbb35c0194ad389b62d48712ecfa2.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/7f774f504deb4312b417c04e3ee11a1e.png
[b5ff79815bf44160af2116f9ad14bc06.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/cd13e11901ec4da48ef81eda4b4b029a.png
[148f2110c52441ea975351b963ca9be7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/071ac3f01d5e427192c7f17d481ae61a.png
[4cb8e0de6ced42b49efdd28404a3a1f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/5c2d19a8fb7c48398ad148b6294040ac.png
[76a39c5954fd4c4c90fa8968e0115954.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/9fce3ea7c51e475d9c1207153536a490.png
[ad3e7083112b4178843cb882103dfc16.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/e2cae368ef7f46da9ad1b95c13e6f1ae.png
[305ccaf25aab4de292991366a28d5334.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/06c1c379ad8b4c20bfbdf88e22fb8d80.png
[81b701862cf64cbca6bc2b6432254d33.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/c60d37dc2efb4b9a889405602501c20f.png
[b8adf02de87b49678ae1f56f8063dedd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/52809650931a4ada8c314bedddba4a6e.png
[bc3c55a0582b4cedbc1ead3b623ab0ef.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/1eefb0a3d2c9408892453132eb4c3314.png
[5ca02ed0598b44d68ce053c5452ef17a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/4ab2eba7e13d49e8a0327d66e9d85d6d.png
[070bfae707c240f4bf1d45f34b51cbc2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/a9d30635921848f98f21f92bb3d95b88.png
[4b4b503d050941b5931f24a2019e5c88.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/417090ffe3a7493d9781bdc64d47c6df.png
[502ecd9cc89a4620a92d93b48e38e586.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/9c99978f7f084ea9b1a3f61259bad273.png
[148a5a80cdf74362a97f415908c2e26c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/fb88f68cffee44bca8786a7638d47c90.png
[0fe07c05b4b04c72a9b91003aa361f91.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/7e963174a642475f9fcb495649f7dfdb.png
[236dbffd216a440b9cee67c97d7dc8d7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/93c1b6af2b794c268f8bd894d430ef6e.png
[0f029bf484da41b39e8370774e462f95.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/e99e410012754424a2a8ec1313b92736.png