【Linux从青铜到王者】第七篇:Linux进程控制

一时失言乱红尘 2022-10-07 08:51 20阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70_pic_center]

# 系列文章目录 #

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

### 文章目录 ###

*  系列文章目录
 *  前言
 *  一、程序地址空间
 *   *   *  1.程序地址空间背景
         *  2.程序地址空间回顾
         *  3.进程地址空间
         *  4.调度队列的本质
 *  二、进程创建
 *   *   *  1.fork函数初识
         *  2.fork函数返回值
         *  3.写时拷贝
         *  4.fork常规用法
         *  5.fork调用失败的原因
 *  三、进程终止
 *   *   *  1.进程退出场景
         *  2.进程常见退出方法
         *  3.\_exit函数
         *  4.exit函数
         *  5.return退出
 *  四、进程等待
 *   *   *  1.进程等待的必要性
         *  2.进程等待的方法
         *   *  1.wait方法
             *  2.waitpid方法
             *  3.获取子进程status
 *  五、进程程序替换
 *   *   *  1.进程程序替换原理
         *  2.进程程序替换函数
         *  3.进程程序替换函数解释
         *  4.进程程序替换函数命名理解
         *  5.进程程序替换函数exec完整例子
         *  6.进程程序替换函数应用场景
 *  总结

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

# 前言 #

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

![在这里插入图片描述][20210618111818511.png_pic_left]

# 一、程序地址空间 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70]

### 1.程序地址空间背景 ###

![在这里插入图片描述][resize_m_lfit_w_962_pic_center]

*  **kernel 2.6.32**
 *  **32位平台**

### 2.程序地址空间回顾 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 1]  
**我们在学习C语言时老师讲过这样的空间布局图:**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 2]

*  **对于一个C语言程序，内存空间主要由5个部分组成：代码段（.text），数据段（.data），BSS区，堆，栈。**
 *  **代码段：代码区,text segment:**存放CPU执行的机器指令（machine instructions）。通常，代码区是可共享的（即另外的执行程序可以调用它），因为对于频繁被执行的程序，只需要在内存中有一份代码即可。代码区通常是只读的，使其只读的原因是防止程序意外地修改了它的指令。另外，代码区还规划了局部变量的相关信息。
 *  **数据段：**存放已初始化全局变量，静态变量（包括全局静态变量和局部静态变量），和常量数据（例如常量字符串)。
 *  **BSS：未初始化数据区，Uninitialized data segment:**存入的是未初始化全局变量，未初始化静态变量，初始化为0的全局变量，初始化为0的静态变量。例如不在任何函数内的声明：int a;BSS 是英文Block Started by Symbol 的简称。BSS 段属于静态内存分配，即程序一开始就将其清零了。一般在初始化时BSS段部分将会清零。
 *  **堆：**用于动态内存分配，程序员自己分配和释放。
 *  **栈：**编译器自动分配和释放，存放局部变量，函数参数，返回数据等。

**栈是向下增长的，堆是向上增长的，最大化了可用空间。**

**下图是更详细的空间布局图：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 3]  
**可能目前对它我们并不是很了解，没关系，看下面一段代码，得出什么结论?**

1	#include<iostream>
         2	#include<unistd.h>
         3	#include<stdlib.h>
         4	int g_val=10;
         5	
         6	int main()
         7	{ 
         8	    pid_t pid=fork();
         9	    if(pid<0)
        10	    { 
        11	        std::cout<<"fork error"<<std::endl;
        12	    }
        13	    else if(pid==0)
        14	    { 
        15	        std::cout<<"child pid="<<getpid()<<std::cout<<" g_val="<<g_val<<std::cout<<" 地址"<<&g_val<<std::endl;
        16	    }
        17	    else
        18	    { 
        19	        std::cout<<"parent pid="<<getpid()<<std::cout<<" g_val="<<g_val<<std::cout<<" 地址"<<&g_val<<std::endl;
        20	    }
        21	    sleep(1);
        22	    return 0;
        23	}

![在这里插入图片描述][20210617095141704.png]  
**我们发现，输出出来的变量值和地址是一模一样的，很好理解呀，因为子进程按照父进程为模版，父子并没有对变量进行进行任何修改。可是将代码稍加改动。**

1	#include<iostream>
         2	#include<unistd.h>
         3	#include<stdlib.h>
         4	int g_val=10;
         5	
         6	int main()
         7	{ 
         8	    pid_t pid=fork();
         9	    if(pid<0)
        10	    { 
        11	        std::cout<<"fork error"<<std::endl;
        12	    }
        13	    else if(pid==0)
        14	    { 
        15	        g_val=100;
        16	        std::cout<<"child pid="<<getpid()<<std::cout<<" g_val="<<g_val<<std::cout<<" 地址"<<&g_val<<std::endl;
        17	    }
        18	    else
        19	    { 
        20	        sleep(3);
        21	        std::cout<<"parent pid="<<getpid()<<std::cout<<" g_val="<<g_val<<std::cout<<" 地址"<<&g_val<<std::endl;
        22	    }
        23	    sleep(1);
        24	    return 0;
        25	}

![在这里插入图片描述][20210617095514242.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 4]

*  **我们发现，父子进程，输出地址是一致的，但是变量内容不一样！能得出如下结论:**
 *  **变量内容不一样,所以父子进程输出的变量绝对不是同一个变量。**
 *  **但地址值是一样的，说明，该地址绝对不是物理地址。**
 *  **在Linux地址下，这种地址叫做 虚拟地址。**
 *  **我们在用C/C++语言所看到的地址，全部都是虚拟地址！物理地址，用户一概看不到，由OS统一管理。**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 5]  
**OS必须负责将 虚拟地址 转化成 物理地址 。**

### 3.进程地址空间 ###

所以之前说**"程序的地址空间"**是不准确的，准确的应该说成**进程地址空间**，那该如何理解呢？看图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 9]  
**通俗来说:**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 10]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 11]

*  **早期内存管理原理：**
 *  要运⾏一个程序，会把这些程序全都装⼊内存。
 *  当计算机同时运⾏多个程序时，必须保证这些程序用到的内存总量要⼩于计算机实际物理内存的⼤⼩问题。
 *  进程地址空间不隔离。由于程序都是直接访问物理内存，所以恶意程序可以随意修改别的进程的内存数据，以达到破坏的目的。
 *  内存使⽤效率低。在 A 和 B 都运⾏的情况下，如果⽤户⼜运⾏了程序 C ，⽽程序 C 需要 15M ⼤ ⼩的内存才能运⾏，而此时系统只剩下 4M 的空间可供使⽤，所以此时系统必须在已运⾏的程序中 选择一个将该程序的数据暂时拷⻉到硬盘上，释放出部分空间来供程序 C 使⽤，然后再将程序 C 的数据全部装入内存中运⾏。
 *  程序运⾏的地址不确定。当内存中的剩余空间可以满足程序 C 的要求后，操作系统会在剩余空间中随机分配一段连续的 20M ⼤⼩的空间给程序 C 使⽤，因为是随机分配的，所以程序运⾏的地址是不确定的，这种情况下，程序的起始地址都是物理地址，而物理地址都是在加载之后才能确定。

**由于以上机制存在问题，那如何将虚拟地址转换为物理地址呢？**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 12]  
**得出结论 ：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 13]

### 4.调度队列的本质 ###

**等待队列:本质是把进程PCB排队的过程。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 14]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 15]

# 二、进程创建 #

### 1.fork函数初识 ###

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

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

*  **进程调用fork，当控制转移到内核中的fork代码后，内核做:**
 *  **分配新的内存块和内核数据结构给子进程。**
 *  **将父进程部分数据结构内容拷贝至子进程。**
 *  **添加子进程到系统进程列表当中。**
 *  **fork返回，开始调度器调度。**

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

1	#include<iostream>
         2	#include<unistd.h>
         3	int main()
         4	{ 
         5	    std::cout<<"I am a process:"<<getpid()<<std::endl;
         6	    pid_t ret=fork();
         7	    if(ret<0)
         8	    { 
         9	        std::cout<<"fork error"<<std::endl;
        10	    }
        11	    else if(ret==0)
        12	    { 
        13	        std::cout<<"I am child,my pid is:"<<getpid()<<" my return:"<<ret<<std::endl;
        14	        sleep(2);
        15	    }
        16	    else 
        17	    { 
        18	        std::cout<<"I am father,my pid is:"<<getpid()<<" my return is:"<<ret<<std::endl;
        19	        sleep(2);
        20	    }
        21	    return 0;
        22	}

![在这里插入图片描述][20210617105355908.png]  
所以，fork之前父进程独立执行，fork之后，父子两个执行流分别执行。注意，fork之后，谁先执行完全由调度器决定。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 16]

### 2.fork函数返回值 ###

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

*  **子进程返回0。**
 *  **父进程返回的是子进程的pid。**

### 3.写时拷贝 ###

**通常，父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。具体见下图：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 17]  
![在这里插入图片描述][20210617110115452.png]  
**理解下面题目:**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 18]

### 4.fork常规用法 ###

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

### 5.fork调用失败的原因 ###

*  **系统中有太多的进程。**
 *  **实际用户的进程数超过了限制。**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 19]

# 三、进程终止 #

### 1.进程退出场景 ###

*  **代码运行完毕，结果正确，退出码为0。**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 20]
 *  **代码运行完毕，结果不正确，退出码不为0。**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 21]
 *  **代码异常终止，出现警告。**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 22]

代码如下：

1	#include<iostream>
         2	#include<unistd.h>
         3	int fun()
         4	{ 
         5	    int i=2/0;
         6	}
         7	int main()
         8	{ 
         9	    std::cout<<"Hello Linux"<<std::endl;
        10	    sleep(1);
        11	    int ret=fun();
        12	    return 0;
        13	}

### 2.进程常见退出方法 ###

*  **正常终止（可以通过 echo $? 查看进程退出码）：**
 *  **从main返回。**
 *  **调用exit。**
 *  **调用\_exit。**
 *  **异常退出：**
 *  **ctrl + c，信号终止。**

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

### 3.\_exit函数 ###

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

> \#include <unistd.h>  
> void \_exit(int status);  
> 参数：status 定义了进程的终止状态，父进程通过wait来获取该值

**说明：虽然status是int，但是仅有低8位可以被父进程所用。所以\_exit(-1)时，在终端执行$?发现返回值是255。**

### 4.exit函数 ###

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

> \#include <unistd.h>  
> void exit(int status);

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 23]

*  **exit最后也会调用exit, 但在调用exit之前，还做了其他工作：**
 *  **执行用户通过 atexit或on\_exit定义的清理函数。**
 *  **关闭所有打开的流，所有的缓存数据均被写入。**
 *  **调用\_exit。**

**那么请看下面结果发现exit和 \_exit的区别：**

*  **使用\_exit系统调用函数：**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 24]
 *  **使用exit库函数：**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 25]

1	#include<iostream>
         2	#include<stdlib.h>
         3	#include<unistd.h>
         4	int main()
         5	{ 
         6	    std::cout<<"你好呀!";
         7	    sleep(1);
         8	    exit(0);
         9	    // _exit(0);
        10	     return 0;
        11	}

**冲刷缓冲区是用回调函数来解决，回调函数我们之前在C语言中已经讲过：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 26]

### 5.return退出 ###

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

# 四、进程等待 #

### 1.进程等待的必要性 ###

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

### 2.进程等待的方法 ###

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

#### 1.wait方法 ####

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

> \#include<sys/types.h>  
> \#include<sys/wait.h>  
> pid\_t wait(int\*status);  
> 返回值：  
> 成功返回被等待进程pid，失败返回-1。  
> 参数：  
> 输出型参数，获取子进程退出状态,不关心则可以设置成为NULL

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 27]

1	#include<iostream>
         2	#include<sys/wait.h>
         3	#include<stdlib.h>
         4	#include<unistd.h>
         5	int main()
         6	{ 
         7	    pid_t pid=fork();
         8	    if(pid<0)
         9	    { 
        10	        std::cout<<"fork error"<<std::endl;
        11	    }
        12	    else if(pid==0)
        13	    { 
        14	        int count=0;
        15	        while(1)
        16	        { 
        17	            sleep(1);
        18	            std::cout<<"i am child"<<std::endl;
        19	            if(count==3)
        20	            { 
        21	                break;
        22	            }
        23	            count++;
        24	        }
        25	        exit(0);
        26	    }
        27	    else 
        28	    { 
        29	        int count=0;
        30	        while(1)
        31	        { 
        32	            sleep(1);
        33	            std::cout<<"i am father"<<std::endl;
        34	            while(count==5)
        35	            { 
        36	               wait(NULL);
        37	            }
        38	            count++;
        39	        }
        40	        exit(0);
        41	       /* std::cout<<"father before...."<<std::endl; 42 wait(NULL); 43 std::cout<<"father after..."<<std::endl;*/
        44	    }
        45	    return 0;
        46	}

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 28]

#### 2.waitpid方法 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 29]

>  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相等的子进程。**  
> **status:  
> WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）。  
> WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码**）。  
> **options:  
> WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。**

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

1	#include<iostream>
         2	#include<sys/wait.h>
         3	#include<unistd.h>
         4	#include<stdlib.h>
         5	int main()
         6	{ 
         7	    pid_t pid=fork();
         8	    if(pid<0)
         9	    { 
        10	        std::cout<<"fork error!\n"<<std::endl;
        11	    }
        12	    else if(pid==0)
        13	    { 
        14	        //child
        15	        int count=0;
        16	        while(count<5)
        17	        { 
        18	            std::cout<<"child is running,pid="<<getpid()<<std::endl;
        19	            sleep(1);
        20	            count++;
        21	        }
        22	        exit(0);
        23	    }
        24	    //father
        25	    std::cout<<"father wait before!"<<std::endl;
        26	    pid_t ret=waitpid(pid,NULL,0);
        27	    if(ret>0)
        28	    { 
        29	        std::cout<<"wait success!"<<std::endl;
        30	    }
        31	    else 
        32	    { 
        33	        std::cout<<"wait failed"<<std::endl;
        34	    }
        35	    std::cout<<"father wait after!"<<std::endl;
        36	    return 0;
        37	}

**看下面结果图发现当父进程调用了waitpid函数时父进程就被阻塞了，阻塞期间当子进程运行完毕父进程才执行完毕，所以只有子进程退出了父进程才会退出，那么子进程就一定不是僵尸进程。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 30]

#### 3.获取子进程status ####

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

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

**测试exit code，exit signal。**

1	#include<iostream>
         2	#include<unistd.h>
         3	#include<sys/wait.h>
         4	#include<stdlib.h>
         5	int main()
         6	{ 
         7	    pid_t pid=fork();
         8	    if(pid<0)
         9	    { 
        10	        std::cout<<"fork error!"<<std::endl;
        11	    }
        12	    else if(pid==0)
        13	    { 
        14	        //child
        15	        int count=0;
        16	        while(count<5)
        17	        { 
        18	            std::cout<<"child is running,pid="<<getpid()<<std::endl;
        19	            sleep(1);
        20	            count++;
        21	        }
        22	        exit(0);
        23	    }
        24	    else 
        25	    { 
        26	        //father
        27	        std::cout<<"father wait before"<<std::endl;
        28	        int st=0;
        29	        pid_t ret=waitpid(pid,&st,0);
        30	        if(ret>0)
        31	        { 
        32	            std::cout<<"wait success!"<<std::endl;
        33	            std::cout<<"st="<<st<<std::endl;
        34	            std::cout<<"child exit signal="<<(st&0x7f)<<std::endl;
        35	            std::cout<<"child exit code="<<((st>>8)&0xff)<<std::endl;
        36	        }
        37	        if((st&0x7F))
        38	        { 
        39	            std::cout<<"child run error!"<<std::endl;
        40	        }
        41	        else 
        42	        { 
        43	            int code=((st>>8)&0xff);
        44	            if(code)
        45	            { 
        46	                std::cout<<"child run success,but result is not right:code="<<code<<std::endl;
        47	            }
        48	            else 
        49	            { 
        50	                std::cout<<"child run success,and resunlt is right:code="<<code<<std::endl;
        51	            }
        52	        }
        53	    }
        54	    std::cout<<"wait after!"<<std::endl;
        55	    return 0;
        56	}

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 32]

# 五、进程程序替换 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 33]

### 1.进程程序替换原理 ###

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

### 2.进程程序替换函数 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 36]

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

*  **execl**

1	#include<stdio.h>
         2	#include<unistd.h>
         3	int main()
         4	{ 
         5	    printf("replace begin!\n");
         6	    execl("/usr/bin/ls","ls","-a","-l",NULL);
         7	    printf("replace after!\n");
         8	    return 0;
         9	}

![在这里插入图片描述][20210618100728115.png]  
**如果execl函数出错的话就不执行execl。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 37]

1	#include<stdio.h>
         2	#include<unistd.h>
         3	int main()
         4	{ 
         5	    printf("replace begin!\n");
         6	    execl("/usr/bin/ls","ls","-a","-l");
         7	    printf("replace after!\n");
         8	    return 0;
         9	}

*  **execv**  
    ![在这里插入图片描述][20210618110619606.png]

1	#include<stdio.h>
         2	#include<unistd.h>
         3	int main()
         4	{ 
         5	    printf("replace begin!\n");
         6	    char* arg[]={ "ls","-a","-l",NULL};
         7	    execv("/usr/bin/ls",arg);
         8	    printf("replace after!\n");
         9	}

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

*  **execvp**  
    ![在这里插入图片描述][20210618110632138.png]

1	#include<stdio.h>
         2	#include<unistd.h>
         3	int main()
         4	{ 
         5	    printf("replace begin!\n");
         6	    char* arg[]={ "ls","-a","-l",NULL};
         7	    execvp("ls",arg);
         8	    printf("replace after!\n");
         9	}

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

*  **execlp**

1	#include<stdio.h>
         2	#include<unistd.h>
         3	int main()
         4	{ 
         5	    printf("replace begin!\n");
         6	    execlp("ls","ls","-a","-l",NULL);
         7	    printf("replace after!\n");
         8	    return 0;
         9	}

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 38]

*  **execle**

**环境变量为空时：**

1	#include<iostream>
         2	#include<unistd.h>
         3	int main()
         4	{ 
         5	    std::cout<<"run begin"<<std::endl;
         6	    //extern char** environ;
         7	    execle("/usr/bin/pwd","/usr/bin/pwd",NULL,NULL);
         8	    std::cout<<"run after"<<std::endl;
         9	    return 0;
        10	}

![在这里插入图片描述][20210618162505163.png]  
**mycmd.c文件**

1	#include<stdio.h>
         2	#include<stdlib.h>
         3	int main()
         4	{ 
         5	    int sum=0;
         6	    int i=0;
         7	    for( i=0;i<100;i++)
         8	    { 
         9	      sum=sum+i;
        10	    }
        11	    printf("sum=%d\n",sum);
        12	    printf("myenv:%s\n",getenv("myenv"));
        13	    return 0;
        14	}

![在这里插入图片描述][20210618105845164.png]  
**myexe.c文件**

1	#include<stdio.h>
         2	#include<unistd.h>
         3	int main()
         4	{ 
         5	    printf("running before!\n");
         6	    char* env[]={ "myenv=Hello Linux!",NULL};
         7	    execle("./mycmd","./mycmd",NULL,env);
         8	    printf("running after!\n");
         9	    return 0;
        10	}

![在这里插入图片描述][20210618105939732.png]  
**makefile文件**

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

*  **execve**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 39]

### 3.进程程序替换函数解释 ###

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

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

### 4.进程程序替换函数命名理解 ###

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

*  **这些函数原型看起来很容易混,但只要掌握了规律就很好记:**
 *  **v(vector) : 参数用数组。**
 *  p(path) **: 有p自动搜索环境变量PATH。**
 *  e(env) **: 表示自己维护环境变量。**
 *  l(list) **: 表示参数采用列表。**  
    ![在这里插入图片描述][2021061811112882.png]

### 5.进程程序替换函数exec完整例子 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 40]

### 6.进程程序替换函数应用场景 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 41]

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

# 总结 #

以上就是今天要讲的内容，本文仅仅介绍了进程控制这一方面的一些知识，而进程提供了大量能使我们快速便捷地处理数据的函数和方法，我们务必掌握。到这里，进程控制就结束了，后序将会有更重要的文章陆续更新，希望大家多多支持！另外如果上述有任何问题，请懂哥指教，不过没关系，主要是自己能坚持，更希望有一起学习的同学可以帮我指正，但是如果可以请温柔一点跟我讲，爱与和平是永远的主题，爱各位了。

![在这里插入图片描述][20210618112641674.jpg_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/8f42771c93ed4f8da599c3b8cecf3d76.png
[20210618111818511.png_pic_left]: /images/20221005/486149f1746f43a8887f400d3d7992d5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70]: /images/20221005/c3b00936773541b79d7c96d83b527098.png
[resize_m_lfit_w_962_pic_center]: /images/20221005/735173199088410e8179f64e52629238.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 1]: /images/20221005/b2129595eff74ea6b99667b363b968c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 2]: /images/20221005/12d345f93c52445799aaca2918499949.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 3]: /images/20221005/9f3ed3c847eb472d9b8cdd9566749ae0.png
[20210617095141704.png]: /images/20221005/c10435d8169649e8bde9a3c4313022a0.png
[20210617095514242.png]: /images/20221005/0607e750cc514d0f9a4bf417e6d41c02.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 4]: /images/20221005/4867bd847f544a26bb303b29e2bfd8c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 5]: /images/20221005/772ec0e6a9c248c19671764e0aa3b5b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 6]: /images/20221005/a43fc6520a9f41bb825d57eeb49db0fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 7]: /images/20221005/9e08a598b5954f33bc659600e4b74ee7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 8]: /images/20221005/86fbe8b5394a4bec89edd8b093830bdf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 9]: /images/20221005/540e804d3fb14d63aceba18f332a2712.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 10]: /images/20221005/f6f5dcaff2fa4a399518e8e62d8ea937.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 11]: /images/20221005/891c58cd117c49bcae949f15b65982f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 12]: /images/20221005/bb52bc7628f64185ad493044c5ff8997.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 13]: /images/20221005/6ee70066a6064d7e9bc2bdfa65918e77.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 14]: /images/20221005/54e2aa13e80a4367abf11f24f2f73093.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 15]: /images/20221005/0574a9cc041547aeb1669df2101ad564.png
[20210617105355908.png]: /images/20221005/86d2c3c883fe46f2b7db784934b28db0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 16]: /images/20221005/c40d1956ae074f798a529b9da23b94a3.png
[20210617105706276.png]: /images/20221005/2ba713ef991f44e2b3367e0555d9e679.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 17]: /images/20221005/ae4d7ca6a3ef4042b18325bf27b5952c.png
[20210617110115452.png]: /images/20221005/0905bb3de7d848458e1b50d0e411830e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 18]: /images/20221005/2a54ee699b314c88bb9f73a0f5403be4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 19]: /images/20221005/bf35c00fa32e438393797e1fa53e09ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 20]: /images/20221005/cbcb33924c46431ca957162ce2a3102c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 21]: /images/20221005/470f935d47b94d30ad604fb4fec9daa8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 22]: /images/20221005/c742a5cecf5247a198a71f51dc284d97.png
[20210617114513982.png]: /images/20221005/14a339783bb74414a806ba709f351031.png
[20210617114618109.png]: /images/20221005/a2b292a3a5464698884d99fbe48af2ef.png
[20210617114630773.png]: /images/20221005/fe163bdfa9494b7587a610567c0ac986.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 23]: /images/20221005/15703e9a0c2e47c6b54ea90ee8440b45.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 24]: /images/20221005/6cb8721d0c8840bd949b506a2b7fbf89.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 25]: /images/20221005/6d4ab99fda344b02990b3d02e02ea60b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 26]: /images/20221005/51063611f5d647c39563f8d21faec500.png
[20210618075752999.png]: /images/20221005/ee3090745ac9404dbad7bf33101a2bd3.png
[2021061809114160.png]: /images/20221005/e81ab44bb6ae41caa02ec38cf1b4a3b4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 27]: /images/20221005/23f91083ac7e4584bda5a33be61eae4b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 28]: /images/20221005/8353e25e21cc495e8d7bc7f0b020e9c0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 29]: /images/20221005/8a34be4b008e4af7bf8b63bf34d38c8b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 30]: /images/20221005/bfa752d7939443dda0dfdf1de7472eab.png
[2021061808524926.png]: /images/20221005/ec5663531ba14391987fb8789397a34d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 31]: /images/20221005/7864f2d4f5e24f0a8ecf4ba315871176.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 32]: /images/20221005/a8d4a1713b2044129b34577e5e265555.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 33]: /images/20221005/16eb4bf53ea84d51a3cb4c34b20c7689.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 34]: /images/20221005/96eb687aef66445dbfb985d05c20f7fc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 35]: /images/20221005/e6e5dd2278674de492cebd873732a9c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 36]: /images/20221005/af7fa167408947f6a8b665a89ce9c746.png
[20210618100728115.png]: /images/20221005/d463a87c3a41488ea3cc5db435545516.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 37]: /images/20221005/19b7661f6ca54f9c8414d00b4f7d019d.png
[20210618110619606.png]: /images/20221005/371525f8bf2d421fbae609ac1a2255cc.png
[20210618101516942.png]: /images/20221005/f4bcdc6244c64aca8405079e531bed49.png
[20210618110632138.png]: /images/20221005/61f5e3de3e4d4fe5a69d84ab4f10b222.png
[20210618101856618.png]: /images/20221005/d74e0073598e440ea86bb60331f32641.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 38]: /images/20221005/c0007dc8b02849fe86bdc4984696ab58.png
[20210618162505163.png]: /images/20221005/f31df37e85d5486aa8b8ac60e10c0dba.png
[20210618105845164.png]: /images/20221005/2fdf9561dc2d45409dea39587c9f1dc2.png
[20210618105939732.png]: /images/20221005/cb44030a3a084e7f98d6e871bd899ddc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 39]: /images/20221005/5e77e8109ec045fe81c022a1f7dff754.png
[20210618093643735.png]: /images/20221005/6fa6143a48434185a659ebaf507aba43.png
[2021061811110948.png]: /images/20221005/ffbf0a63a14247beb6748d0ceaa6a6ce.png
[2021061811112882.png]: /images/20221005/9578ac3ea58c44bd84d9ebc71d5330b7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 40]: /images/20221005/43bccc470e4c45bba29eb8959fd4c133.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 41]: /images/20221005/02c09a6e398e42d4a2d07783093a0e53.png
[20210618112641674.jpg_pic_center]: /images/20221005/1873f85530894d43a27b15897155d054.png