【Linux从青铜到王者】第十篇:Linux进程间通信第二篇

逃离我推掉我的手 2022-10-11 15:54 154阅读 0赞

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

# 系列文章目录 #

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

### 文章目录 ###

*  系列文章目录
 *  前言
 *  一、命名管道的定义
 *   *   *  1、创建一个命名管道
         *  2、匿名管道与命名管道的区别
         *  3、命名管道的打开规则
         *  4、命名管道的应用
 *  二、system V共享内存
 *   *   *  1.共享内存示意图
         *  2.共享内存数据结构
         *  3.共享内存函数
         *   *  1.shmget函数
             *  2.shmat函数
             *  3.shmdt函数
             *  4.shmctl函数
 *  三、system V消息队列 － 选学了解即可
 *  四、system V信号量P和V － 选学了解即可
 *  总结

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

# 前言 #

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

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

# 一、命名管道的定义 #

*  **匿名管道应用的一个限制就是只能在具有共同祖先（具有亲缘关系）的进程间通信。**
 *  **如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。**
 *  **命名管道是一种特殊类型的文件。**

### 1、创建一个命名管道 ###

*  **命名管道可以从命令行上创建，命令行方法是使用下面这个命令，mkfifo也是一个指令，可以直接创建管道：**  
    ![在这里插入图片描述][20210701175936836.png]

> $ **mkfifo pipe**

![在这里插入图片描述][20210701180138384.png]  
**read.cpp**

include<iostream>
    #include<fcntl.h>
    #include<unistd.h>
    #include<sys/types.h>
    #include<sys/stat.h>
    int main()
    { 
        int fd=open("./pipe",O_RDONLY);
        if(fd<0)
        { 
            std::cout<<"打开管道文件失败!"<<std::endl;
            return 1;
        }
        char buf[64]={ 0};
        read(fd,buf,sizeof(buf));
        std::cout<<buf<<std::endl;
        return 0;
    }

**write.cpp**

1	#include<iostream>
         2	#include<unistd.h>
         3	#include<sys/stat.h>
         4	#include<sys/types.h>
         5	#include<fcntl.h>
         6	int main()
         7	{ 
         8	    int fd=open("./pipe",O_WRONLY);
         9	    if(fd<0)
        10	    { 
        11	        std::cout<<"打开管道文件失败!"<<std::endl;
        12	        return 1;
        13	    }
        14	    char str[]="bit education!";
        15	    write(fd,str,sizeof(str)-1);
        16	    return 0;
        17	}
        18

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

> **\[yyw@VM-0-9-centos 创建命名管道\]$ ls / > pipe**  
> **\[yyw@VM-0-9-centos 创建命名管道\]$ cat < pipe**

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

*  **命名管道也可以从程序里创建，相关函数有系统调用mkfifo：**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 1]

1	#include<stdio.h>
         2	#include<sys/types.h>
         3	#include<sys/stat.h>
         4	int main()
         5	{ 
         6	    mkfifo("pipe",0664);
         7	    return 0;
         8	}

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

### 2、匿名管道与命名管道的区别 ###

*  **匿名管道由pipe函数创建并打开。**
 *  **命名管道由mkfifo函数创建，打开用open。**
 *  **FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在它们创建与打开的方式不同，一但这些工作完成之后，它们具有相同的语义。**

### 3、命名管道的打开规则 ###

*  **如果当前打开操作是为读而打开FIFO时:**
 *  **O\_NONBLOCK disable：阻塞直到有相应进程为写而打开该FIFO。**
 *  **O\_NONBLOCK enable：立刻返回成功。**
 *  **如果当前打开操作是为写而打开FIFO时：**
 *  **O\_NONBLOCK disable：阻塞直到有相应进程为读而打开该FIFO。**
 *  **O\_NONBLOCK enable：立刻返回失败，错误码为ENXIO。**

### 4、命名管道的应用 ###

**实现客户端与服务端的通信：**

*  **服务端创建管道，打开管道，从管道读数据：**

1	#include<stdio.h>
         2	#include<unistd.h>
         3	#include<sys/stat.h>
         4	#include<fcntl.h>
         5	#include<sys/types.h>
         6	
         7	#define FIFO_FILE "./fifo"
         8	int main()
         9	{ 
        10	    umask(0); 
        11	    if(mkfifo(FIFO_FILE,0666)==-1)
        12	    { 
        13	        printf("创建管道失败!\n");
        14	        return 1;
        15	    }//创建管道
        16	
        17	
        18	    int fd=open(FIFO_FILE,O_RDONLY);// 
        19	    if(fd<0)
        20	    { 
        21	        printf("打开管道失败!\n");
        22	        return 1;
        23	    }
        24	    else if(fd >=0)
        25	    { 
        26	        char buf[64];
        27	        while(1)
        28	        { 
        29	            printf("please wait!\n");
        30	            ssize_t s=read(fd,buf,sizeof(buf)-1);//减一是预留\0位置
        31	            if(s>0)
        32	            { 
        33	                buf[s]=0;
        34	                printf("client# %s",buf);
        35	            }
        36	            else if(s==0)
        37	            { 
        38	                printf("cilent exit!\n");
        39	                break;
        40	            }
        41	            else 
        42	            { 
        43	                printf("文件读取失败!\n");
        44	                break;
        45	            }
        46	        }
        47	    }
        48	    return 0;
        49	}

*  **客户端打开管道，写数据到管道中，发送给服务端：**

1	#include<stdio.h>
         2	#define FIFO_FILE "./fifo"
         3	#include<sys/stat.h>
         4	#include<sys/types.h>
         5	#include<fcntl.h>
         6	#include<unistd.h>
         7	int main()
         8	{ 
         9	    int fd=open(FIFO_FILE,O_WRONLY);
        10	    if(fd<0)
        11	    { 
        12	        printf("文件打开失败!\n");
        13	        return 1;
        14	    }
        15	    else if (fd>=0)
        16	    { 
        17	        char buf[64];
        18	        while(1)
        19	        { 
        20	            printf("please Enter message# ");
        21	            fflush(stdout);
        22	            ssize_t s =read(0,buf,sizeof(buf)-1);
        23	            if(s>0)
        24	            { 
        25	                buf[s]=0;
        26	                write(fd,buf,s);
        27	            }
        28	        }
        29	    }
        30	    return 0;
        31	}

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

# 二、system V共享内存 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 3]  
**共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据。**

### 1.共享内存示意图 ###

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

### 2.共享内存数据结构 ###

> struct shmid\_ds \{  
> struct ipc\_perm shm\_perm; /\* operation perms */  
> int shm\_segsz; /* size of segment (bytes) */  
> \_\_kernel\_time\_t shm\_atime; /* last attach time */ **最后关联时间**  
> \_\_kernel\_time\_t shm\_dtime; /* last detach time */ **最后去除关联时间**  
> \_\_kernel\_time\_t shm\_ctime; /* last change time */**属性最后修改时间**  
> \_\_kernel\_ipc\_pid\_t shm\_cpid; /* pid of creator */  
> \_\_kernel\_ipc\_pid\_t shm\_lpid; /* pid of last operator */  
> unsigned short shm\_nattch; /* no. of current attaches */  
> unsigned short shm\_unused; /* compatibility \*/  
> void *shm\_unused2; /* ditto - used by DIPC \*/  
> void *shm\_unused3; /* unused \*/  
> \};

### 3.共享内存函数 ###

**首先要看到同一份资源，那么必须有标识操作系统上ipc资源的唯一性，就要用到ftok函数:**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][20210705205306747.png]

#### 1.shmget函数 ####

![在这里插入图片描述][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]

> **功能：用来创建共享内存**  
> **原型:**  
> **int shmget(key\_t key, size\_t size, int shmflg);**  
> **参数：**  
> **key:这个共享内存段名字。  
> size:共享内存大小。  
> shmflg:由九个权限标志构成，它们的用法和创建文件时使用的mode模式标志是一样的。  
> 返回值：成功返回一个非负整数，即该共享内存段的标识码；失败返回-1。**  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 8]

1	#pragma once  //防止头文件重复包含
         2	#ifndef __ADD_H_
         3	#define __ADD_H__
         4	#endif
         5	
         6	#define PATHNAME "/tmp"
         7	#define PROJ_ID 0x6688
         8	#define SIZE 4096
         9

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

1	#include<stdio.h>
         2	#include<sys/types.h>
         3	#include"comm.h"
         4	#include<sys/ipc.h>
         5	#include<sys/shm.h>
         6	int main()
         7	{ 
         8	    key_t k=ftok(PATHNAME,PROJ_ID);
         9	    printf("key=%d\n",k);
        10	
        11	    int shmid=shmget(k,SIZE,IPC_CREAT|IPC_EXCL);
        12	    if(shmid<0)
        13	    { 
        14	        printf("创建共享内存失败!\n");
        15	    }
        16	    return 0;
        17	}

![代码如下（示例）：][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 10]  
**这里可以使用ipcs -m 查看共享内存：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 11]  
**如果要删除共享内存使用ipcrm -m shmid就可以:**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 12]

#### 2.shmat函数 ####

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

> **功能：将共享内存段连接到进程地址空间**  
> **原型：**  
> void *shmat(int shmid, const void shmaddr, int shmflg);*  
> **参数：**  
> **shmid: 共享内存标识  
> shmaddr:指定连接的地址  
> shmflg:它的两个可能取值是SHM\_RND和SHM\_RDONLY  
> 返回值：成功返回一个指针，指向共享内存第一个节；失败返回-1**

![在这里插入图片描述][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	#include<stdio.h>
         2	#include<unistd.h>
         3	#include<sys/types.h>
         4	#include"comm.h"
         5	#include<sys/ipc.h>
         6	#include<sys/shm.h>
         7	int main()
         8	{ 
         9	    key_t k=ftok(PATHNAME,PROJ_ID);
        10	    printf("key=%p\n",k);
        11	
        12	    int shmid=shmget(k,SIZE,IPC_CREAT|0664);
        13	    if(shmid<0)
        14	    { 
        15	        printf("创建共享内存失败!\n");
        16	        return 0;
        17	    }
        18	    char* addr=(char*)shmat(shmid,NULL,0);
        19	    if(addr==NULL)
        20	    { 
        21	        printf("关联失败!\n");
        22	        return 0;
        23	    }
        24	    while(1)
        25	    { 
        26	        printf("%s\n",(char*)addr);
        27	        sleep(1);
        28	    }
        29	    //shmdt(addr);
        30	    shmctl(shmid,IPC_RMID,NULL);
        31	    return 0;
        32	}

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

#### 3.shmdt函数 ####

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

> **功能：将共享内存段与当前进程脱离**  
> **原型:**  
> int shmdt(const void \*shmaddr);  
> **参数:**  
> **shmaddr: 由shmat所返回的指针  
> 返回值：成功返回0；失败返回-1  
> 注意：将共享内存段与当前进程脱离不等于删除共享内存段**  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 18]

#### 4.shmctl函数 ####

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

> **功能：用于控制共享内存**  
> **原型:**  
> int shmctl(int shmid, int cmd, struct shmid\_ds \*buf);  
> **参数:**  
> **shmid:由shmget返回的共享内存标识码  
> cmd:将要采取的动作（有三个可取值）  
> buf:指向一个保存着共享内存的模式状态和访问权限的数据结构  
> 返回值：成功返回0；失败返回-1**  
> ![在这里插入图片描述][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]  
**完整的客户端与服务端通信的代码**  
**server.c:**

1	#include<stdio.h>
         2	#include"head.h"
         3	#include<unistd.h>
         4	#include<sys/types.h>
         5	#include<sys/ipc.h>
         6	#include<sys/shm.h>
         7	int main()
         8	{ 
         9	    key_t k=ftok(PATHNAME,PROJ_ID);
        10	    printf("key=%d\n",k);
        11	    int shmid=shmget(k,SIZE,IPC_CREAT|IPC_EXCL|0666);//创建共享内存
        12	
        13	    if(shmid==-1)
        14	    { 
        15	        printf("创建共享内存失败!\n");
        16	        return 1;
        17	    }
        18	    printf("shmid=%d\n",shmid);
        19	    sleep(10);
        20	
        21	    char* str=(char*)shmat(shmid,NULL,0);//关联共享内存
        22	   // sleep(5);
        23	   while(1)
        24	   { 
        25	       sleep(1);
        26	       printf("%s\n",str);
        27	   }
        28	
        29	    shmdt(str);//去除关联的共享内存
        30	   // sleep(5);
        31	
        32	    shmctl(shmid,IPC_RMID,NULL);//删除共享内存
        33	    sleep(5);
        34	    return 0;
        35	}

**client.c:**

1	#include<stdio.h>
         2	#include"head.h"
         3	#include<unistd.h>
         4	#include<sys/types.h>
         5	#include<sys/ipc.h>
         6	#include<sys/shm.h>
         7	int main()
         8	{ 
         9	    key_t k=ftok(PATHNAME,PROJ_ID);
        10	    printf("key=%p\n",k);
        11	    int shmid=shmget(k,SIZE,0);//创建共享内存
        12	
        13	    if(shmid==-1)
        14	    { 
        15	        printf("创建共享内存失败!\n");
        16	        return 1;
        17	    }
        18	    printf("shmid=%d\n",shmid);
        19	   // sleep(10);
        20	
        21	    char* str=(char*)shmat(shmid,NULL,0);//关联共享内存
        22	   // sleep(5);
        23	
        24	
        25	    char c='a';
        26	    for(c;c<='z';c++)
        27	    { 
        28	        str[c-'a']=c;
        29	        sleep(3);
        30	    }
        31	    shmdt(str);//去除关联的共享内存
        32	    sleep(5);
        33	
        34	   // shmctl(shmid,IPC_RMID,NULL);//删除共享内存
        35	   // sleep(10);
        36	    return 0;
        37	}

**makefile:**

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

**head.h:**

1	#pragma once 
         2	#define PATHNAME "/tmp"
         3	#define PROJ_ID 0x6688
         4	
         5	#define SIZE 4096

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 23]  
**ipcs 命令的扩展:**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 24]

# 三、system V消息队列 － 选学了解即可 #

*  **消息队列提供了一个从一个进程向另外一个进程发送一块数据的方法。**
 *  **每个数据块都被认为是有一个类型，接收者进程接收的数据块可以有不同的类型值。**
 *  **IPC资源必须删除，否则不会自动清除，除非重启，所以system V IPC资源的生命周期随内核。**

# 四、system V信号量P和V － 选学了解即可 #

**信号量主要用于同步和互斥的，下面先来看看什么是同步和互斥。**

*  **进程互斥**
 *  **由于各进程要求共享资源，而且有些资源需要互斥使用，因此各进程间竞争使用这些资源，进程的这种关系为进程的互斥。**
 *  **系统中某些资源一次只允许一个进程使用，称这样的资源为临界资源或互斥资源。**
 *  **在进程中涉及到互斥资源的程序段叫临界区。**
 *  **IPC资源必须删除，否则不会自动清除，除非重启，所以system V IPC资源的生命周期随内核。**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 25]

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

# 总结 #

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

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/0eaa2b392ea444789185758884ed5b29.png
[20210701175507385.png_pic_left]: /images/20221005/0f88ec79479d41ae96008359962e08d8.png
[20210701175936836.png]: /images/20221005/6fd603f1ff13493b987d754af1947104.png
[20210701180138384.png]: /images/20221005/98cfce8ea21546cd934d7d45254cfe03.png
[20210705194453522.png]: /images/20221005/46633290e01f4775a1933f3e6971d689.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70]: /images/20221005/e65715e15ab1464c89904e5470f11dad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 1]: /images/20221005/58d3a1e99823490e881debdb3e6caf05.png
[20210701181419170.png]: /images/20221005/86a1a8704c614e4b99ca0232d46aee1a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 2]: /images/20221005/f6bea8cfd7ca4dd685e8d527aeef586a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 3]: /images/20221005/6b4571f648a146058eed7fe75571784c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 4]: /images/20221005/95b5a6f9ce1349ac9f84771b0164a60d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 5]: /images/20221005/8ef8b7c31d2a45dd9d92054ff88ae4ba.png
[20210705205306747.png]: /images/20221005/0d29c510a69c453a851db05dbf6ffc7a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 6]: /images/20221005/33773491b9db493384f6005567ab50a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 7]: /images/20221005/041a038d082f4bf0a6af1323ede54f80.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 8]: /images/20221005/7f7d8501a10745bd870b1525661a2bf2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 9]: /images/20221005/bcd1d01d10fb4ceba8eafbbaa0e85c99.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 10]: /images/20221005/63482254007d4190868d2c826d2db5bd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 11]: /images/20221005/1717c084f8e246d1b007305e3ce91b6d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 12]: /images/20221005/9c892617cefd41e595d2fee7560870b7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 13]: /images/20221005/4ebdf93711ed42d9b33605da806a3bd4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 14]: /images/20221005/4b40933f1f124f75a4b9cf1f65b9591a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 15]: /images/20221005/98d659f60fbe4eb6a39714e25058d641.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 16]: /images/20221005/d5a0788d6aa447f6a889e9ba643449ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 17]: /images/20221005/a653490fc69b4b68b9f400611211cf54.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 18]: /images/20221005/46b2c01a3db74cdd8749e929f1b92761.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 19]: /images/20221005/f53730992eaf45aca42206c7c5ad4f4f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 20]: /images/20221005/af97f7b508e64a638f25d0144d1014ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 21]: /images/20221005/5e5688c807fb452eb13bac604cb39596.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 22]: /images/20221005/1c5812fb2dca419e81b76cf77c453cab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 23]: /images/20221005/e0c94fc0eed84168a083d536064555cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 24]: /images/20221005/b4f67d0ccf9e4396a43ac77823b2beab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0OTE4MDkw_size_16_color_FFFFFF_t_70 25]: /images/20221005/92e259be961249d4ba7bca5c9c9a9375.png
[20210701204941936.png_pic_center]: /images/20221005/3529c177b3c6452b901af6ed4031cc6c.png