进程同步与经典问题

迈不过友情╰ 2023-01-16 04:49 138阅读 0赞

# 进程同步 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70][]

# 1. 临界区的实现方式 #

<table> 
 <tbody> 
  <tr> 
   <th colspan="1">&nbsp;</th> 
   <th>方法</th> 
   <td>内容</td> 
   <td style="width:263px;">优缺点</td> 
  </tr> 
  <tr> 
   <th colspan="1">软件实现</th> 
   <th>单标志法</th> 
   <td>设置一个公用整型变量turn,表示被允许进入临界区的进程编号</td> 
   <td style="width:263px;">违背“空闲让进”</td> 
  </tr> 
  <tr> 
   <th>双标志先检查</th> 
   <td>设置一个标记数组，在每个进程访问临界资源之前先检查，再设置该进程正在访问</td> 
   <td style="width:263px;">违背“忙则等待”</td> 
  </tr> 
  <tr> 
   <th>双标志后检查</th> 
   <td>设置一个标记数组，先检测对方的进程状态标志，再设置自己的标志</td> 
   <td style="width:263px;">违背“优先等待”，可能会导致饥饿现象</td> 
  </tr> 
  <tr> 
   <th>Peterson's Algorithm</th> 
   <td>综合前三个优点，标记数组+变量turn，每个进程先设置自己的标志后在设置turn标志，最后检查对方的标志和此时的turn变量</td> 
   <td style="width:263px;">违背“让权等待”</td> 
  </tr> 
  <tr> 
   <th colspan="1">硬件实现</th> 
   <th>中断屏蔽</th> 
   <td>&nbsp;</td> 
   <td colspan="1" style="width:263px;"> <p>优点：适用于任意数目的进程与处理机，简单、容易验证</p> <p>缺点：进程等待进入临界区时需要耗费处理机时间，不能实现“让权等待”</p> </td> 
  </tr> 
  <tr> 
   <th>硬件指令</th> 
   <td>TestAndSet指令、Swap指令</td> 
  </tr> 
 </tbody> 
</table>

## 1.1 单标志法 ##

P0进程
    while(turn!=0);    //进入区
    critical section;  //临界区
    turn=1;            //退出区
    remainder section; //剩余区
    
    P1进程
    while(turn!=1);    //进入区
    critical section;  //临界区
    turn=1;            //退出区
    remainder section; //剩余区

## 1.2 双标志先检查 ##

Pi进程:
    while(flag[i]);   (1)     //进入区
    flag[i]=TRUE;     (3)
    critical section;         //临界区
    flag[i]=FALSE;            //退出区
    remainder section;        //剩余区
    
    Pj进程:
    while(flag[j]);   (2)     //进入区
    flag[j]=TRUE;     (4)
    critical section;         //临界区
    flag[j]=FALSE;            //退出区
    remainder section;        //剩余区
    
    当按照（1）（2）（3）（4）的顺序实现时违背“忙则等待”

## 1.3 双标志后检查 ##

Pi进程:
    flag[i]=TRUE;      (1)    //进入区
    while(flag[i]);    (3)
    critical section;         //临界区
    flag[i]=FALSE;            //退出区
    remainder section;        //剩余区
    
    Pj进程:
    flag[j]=TRUE;      (2)   //进入区
    while(flag[j]);    (4)
    critical section;         //临界区
    flag[j]=FALSE;            //退出区
    remainder section;        //剩余区
    
    当按照（1）（2）（3）（4）的顺序实现时违背“有限等待”，会导致“饥饿现象”

## 1.4 Peterson's Algorithm ##

Pi进程:
    flag[i]=TRUE;turn=j          (1)    //进入区
    while(flag[j]&&turn==j);     (3)    //如果j进程标志为true,并且是被让出来的，自己就阻塞
    critical section;                   //临界区
    flag[i]=FALSE;                      //退出区
    remainder section;                  //剩余区
    
    Pj进程:
    flag[j]=TRUE;rurn=i          (2)   //进入区
    while(flag[i]&&turn==i);     (4)
    critical section;                  //临界区
    flag[j]=FALSE;                     //退出区
    remainder section;                 //剩余区
    
    当按照（1）（2）（3）（4）的顺序实现时，flag[i]==true且turn=i,while进行循环，j进程阻塞。
    最后一次‘让’的进程后执行

## 1.5 中断屏蔽方法 ##

...
    关中断；
    临界区；
    开中断；
    ...

## 1.6 TestAndSet指令 ##

boolean TestAndSet(boolean *lock){
     boolean old;
     old=*lock;
     *lock=true;
     return old;
    }
    
    //为每一个临界资源设置一个共享变量lock,表示资源的两种状态：true表示正在被占用，初始值为false.
    //进程在访问临界资源之前，使用TestAndSet检查和修改标志lock,如果有进程在临界区，则重复检查直到进程退出。
    
    while TestAndSet(&lock)；
    进程的临界区代码；
    lock=false;
    进程的其他代码；

## 1.7 Swap指令 ##

Swap(boolean *a, boolean *b){
     boolean temp;
     temp=*a;
     *a=*b;
     *b=temp;
    }
    
    //为每一个临界资源设置共享布尔变量lock,初始值为false,在每个进程中设置局部布尔变量key,与lock交换信息。
    //进入临界区前用Swap指令交换信息，然后检查key状态;有进程在临界区时，重复交换和检查过程。
    
    key=false;
    while(key！=false)
     Swap(&lock, &key);
    进程的临界区代码段；
    lock=false;
    进程的其他代码；

# 2. 信号量 #

信号量是一个变量（可以是整数，也可以是更复杂的记录型变量），可以用一个信号量来表示系统中某种资源的数量。

## **2.1 整型信号量** ##

用一个整数型的变量作为信号量，用来表示系统中某种资源的数量。与普通整数变量的区别是对信号量是对信号量的操作只有三种：初始化、P操作、V操作。

存在的问题：不满足让权等待原则。

int S = 1;  //初始化整形信号量S,表示当前系统中可用的资源数
    
    //“检查”和“上锁”一气呵成，避免了并发、异步导致的问题
    
    void wait (int S){    //wait 原语，相当于“进入区”
     while (S <= 0);      //如果资源数不够，就一直循环等待,可能导致“忙等”
     S = S - 1;           //如果资源数够，则占用一个资源
    }
    
    void singal (int S){  //signal 原语，相当于“退出区”
     S = S + 1;           //使用完资源后，在退出区释放资源
    }
    
    
    进程P0:
    ...
    wait(S);     //进入区，申请资源
    使用资源...   //临界区，访问资源
    singal(S);   //退出区，释放资源
    ...
    
    
    进程P1:
    ...
    wait(S);     //进入区，申请资源
    使用资源...   //临界区，访问资源
    singal(S);   //退出区，释放资源
    ...

## **2.2 记录型信号量** ##

用记录型数据结构表示的信号量，实现系统资源的“申请”和“释放”，实现进程互斥、进程同步。

// 定义
    typedef struct{
     int value;           //剩余资源数
     struct process *L;   //等待队列
    }semaphore;
    
    // 某进程需要使用资源时，通过wait原语申请
    void wait (semaphore S){
     S.value--;    //表示资源数减一
     if (S.value < 0){
      block(S.L); //如果剩余资源数不够，使用block原语市金城从运行状态进入阻塞状态，
                  //并挂载到信号量的S的等待队列（即阻塞队列）中，遵循“让权等待”。
     }
    }
    
    
    //进程使用完资源之后，通过singal原语释放
    void signal (semaphore S){
     S.value++;    //释放一个资源
     if (S.value <= 0){
      wakeup(S.L); //释放资源后，如果还有别的进程在等待这种资源，则使用weakup原语唤醒
                   //队列中的一个进程，为该进程从阻塞状态变为就绪态
     }
    }

## **2.3 信号量机制实现进程互斥** ##

1.分析并发进程的关键活动，划定临界区

2.设置互斥信号量mutex,初始值为1

3.在进入区P(mutex)--申请资源

4.在退出区V(metux)--释放资源

注：对不同的临界资源需要设置不同的互斥信号量，P、V操作必须成对出现。

//信号量机制实现互斥
    semaphore mutex=1;
    
    p1(){
    ...
    P(mutex);       //使用临界资源前需要加锁
    临界区代码段...
    V(mutex);       //使用临界资源后需要解锁
    ...
    }
    
    p2(){
    ...
    P(mutex);       //使用临界资源前需要加锁
    临界区代码段...
    V(mutex);       //使用临界资源后需要解锁
    ...
    }

## **2.4 信号量进制实现进程同步** ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 1][]

1.分析什么地方需要实现“同步关系”，即必须保证“一前一后”执行两个操作

2.设置同步信号量S，初始值为0

3.在“前操作”之后执行V(S)

4.在“后操作”之前执行P(V)

//初始值为0 刚开始没有这种资源，P2需要而又只能由P1产生
    semaphore S=0;

![20210424004303622.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 2][]

## **2.5 信号量机制实现前驱关系** ##

1.把每一对前驱关系都看成一个同步问题

2.为每一对前驱关系设置同步信号量，初始值0

3.在每个“前操作”之后执行V操作

4.在每个“后操作”之前执行P操作

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 3][]

# 3. 经典同步问题 #

## **3.1 生产者-消费者问题（单纯进程同步一对一问题）** ##

**问题1描述**：一组生产者进程和一组消费者进程共享一个初始为空、大小为n的缓冲区，只有缓冲区没满时，生产者才能把产品放入缓冲区，否则必须等待；只有缓冲区不空时，消费者才能从中取出产品，否则继续等待。

![2021042401052718.png][]

semaphore mutex=1;  //互斥信号量，实现对缓冲区的互斥访问
    semaphore empty=n;  //同步信号量，表示空闲缓冲区的数量
    semaphore full=0;   //同步信号量，表示非空缓冲区的数量

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 5][]

因此，实现互斥的P操作一定要在实现同步的P操作之后（否则容易引起死锁），但是两个V操作顺序可以交换。

**问题2描述**：桌子上有一只盘子，每次只能向其中放入一个水果。爸爸专向盘子中放苹果，妈妈专向盘子中放橘子，女儿专等着吃盘子中的苹果，儿子专等着吃盘子中的橘子。只有盘子为空时，爸爸或妈妈才可以向盘子中放入一个水果。仅且仅当盘子中有自己所需要的水果时，儿子或女儿可以从盘子中取出水果。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 6][]

1.关系分析

互斥关系：对缓冲区（盘子）的访问是要互斥进行的

同步关系：父亲放苹果之后，女儿才能取；母亲放橘子之后，儿子才能取；盘子为空时，才能放水果。

2.整理思路：前V后P

3.设置信号量

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 7][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 8][]

其中：如果不设置互斥变量mutex,也不会出现多个进程同时访问盘子的现象

原因：本题中的缓冲区大小为1，在任何时刻，最多只有一个进程的P操作不会被阻塞，并顺利的进入临界区，但如果盘子容量为2的话，就必须设置互斥变量。

## 3.2 读者-写者问题（一个进程与同类型进程同步与其他类型进程互斥的问题） ##

**问题描述：**有读者和写者两个并发进程，共享一个文件，当两个或两个以上的进程同时访问共享数据时捕获产生副作用，但是若某个写进程和其他进程同时访问共享数据时则可能到时数据不一致的错误。

**要求：**（1）允许多个读者同时读文件；（2）同一时间内只允许一个写者写文件；（3）写者与其他进程之间对文件操作是互斥的；（4）写者在执行操作前，已有的写者和读者全部退出。

**原因：**读者的操作不会改变文件数据，而写者的操作会改变文件数据，因此要求写者与其他进程之间对文件的操作应该是互斥进行的。

**分析：**

（1）读写进程是互斥的；

（2）文件内数据数目；

（3）对文件内数据的检查需要“一气呵成”；

**核心思想：**采用count计数器记录当前正在访问共享文件的读进程数，用来判断当前进入的进程是否是第一个/最后一个读进程，从而做出不同的处理。

//信号量设置
    semaphorn rw=1;      
    int count=0;
    semaphore mutex=1;   //对count的互斥访问

**读者-写者（读优先）**

writer() {
      while(1) {
        P(rw);
        写文件；
        V(rw);
      }
    }
    
    reader() {
     while(1) {
       P(mutex);     //对数据的互斥访问
       if(count==0)
         P(rw);      //如果当前是第一个读者，进行一次“加锁”
       count++;
       V(mutex);     //对数据的互斥访问
       读文件；
       P(mutex);
       count--;
       if(count==0)
         V(rw);       //如果当前是最后一个读者，进行一次“解锁”
       V(mutex);
      } 
    }

可能出现的问题：一直有读者来读取数据，count不为0，文件数据一直被读者们占用，写者会出现“饥饿”现象。

**读者-写者优化（先来先服务）**

增加一个信号量，用于实现“写优先”，是相对公平的先来先服务原则。

semaphore w=1;
    
    writer() {
      while(1) {
        P(w);        //先写，执行w--;如果w==1,“加锁”，进行下一步；否则，“阻塞”。
        P(rw);
        写文件；
        V(rw);
        V(w);
      }
    }
    
    reader() {
     while(1) {
       P(w);         //实现写优先
       P(mutex);     //对数据的互斥访问
       if(count==0)
         P(rw);      //如果当前是第一个读者，进行一次“加锁”
       count++;
       V(mutex);     //对数据的互斥访问
       V(w);         //实现写优先
       读文件；
       P(mutex);
       count--;
       if(count==0)
         V(rw);       //如果当前是最后一个读者，进行一次“解锁”
       V(mutex);
      } 
    }

## 3.3 哲学家进餐问题（一个进程需要多个临界资源与死锁问题） ##

**问题描述：**一张圆桌上坐着5名哲学家，每两个哲学家之间的桌上摆一根筷子，桌子的中间是一碗米饭。哲学家们倾注毕生的精力用于思考和进餐，哲学家在思考时，并不影响他人。只有当哲学家饥饿时，才试图拿起左、右两根筷子(一根一根地拿起)。如果筷子已在他人手上，则需等待。饥饿的哲学家只有同时拿起两根筷子才可以开始进餐，当进餐完毕后，放下筷子继续思考。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 9][]

1.关系分析。系统中有5个哲学家进程，5位哲学家与左右邻居对其中间筷子的访问是互斥关系。

2.整理思路。这个问题中只有互斥关系，但与之前遇到的问题不同的事，每个哲学家进程需要同时持有两个临界资源才能开始吃饭。如何避免临界资源分配不当造成的死锁现象，是哲学家问题的精髓。  
  
3. 信号量设置。定义互斥信号量数组  
  
chopstick\[5\]=\{1,1,1,1,1\}用于实现对5个筷子的互斥访问。并对哲学家按0~4编号，哲学家i左边的筷子编号为i,右边的筷子编号为(i+1)%5。

### 如何避免死锁？ ###

①可以对哲学家进程施加一些限制条件，比如最多允许四个哲学家同时进餐。这样可以保证至少有一个哲学家是可以拿到左右两只筷子的  
  
②要求奇数号哲学家先拿左边的筷子，然后再拿右边的筷子，而偶数号哲学家刚好相反。用这种方法可以保证如果相邻的两个奇偶号哲学家都想吃饭，那么只会有其中一个可以拿起第一只筷子， 另一个会直接阻塞。这就避免了占有一支后再等待另一只的情况。

**信号量设置：**

semaphorn chopstick[5]={1,1,1,1,1};
    semaphorn mutex=1;     //互斥的取筷子

**哲学家进程：**

Pi() {
     P(mutex);
     P(chopstick[i];       //拿左
     P(chopstick[(i+1)%5]; //拿右
     V(mutex)；
     吃饭...
     V(chopstick[i];       //放左
     V(chopstick[(i+1)%5]; //放右
     思考...
    }

这种方法不能保证两边同时有筷子的哲学家就一定能拿起筷子，比如0号哲学家拿起了左右筷子之后，在还没执行V操作之前，这时，虽然2号哲学家左右都有筷子，但是由于此时mutex==0，所以2号进程P(mutex)会将该进程阻塞。

如何实现更准确的说法应该是:各哲学家拿筷子这件事必须互斥的执行。这就保证了即使一个哲学家在拿筷子拿到一半时被阻塞，也不会有别的哲学家会继续尝试拿筷子。这样的话，只有当前正在吃饭的哲学家放下筷子后， 被阻塞的哲学家就可以获得等待的筷子了。

## 3.4 吸烟者问题 ##

**问题描述：**假设一个系统有三个抽烟者进程和一个供应者进程。每个抽烟者不停地卷烟并抽掉它，但是要卷起并抽掉一支烟，抽烟者需要有三种材料:烟草、纸和胶水。三个抽烟者中，第-一个拥有烟草、第二个拥有纸、第三个拥有胶水。供应者进程无限地提供三种材料，供应者每次将两种材料放桌子上，拥有剩下那种材料的抽烟者卷一根烟并抽掉它， 并给供应者进程-一个信号告诉完成了，供应者就会放另外两种材料再桌上，这个过程一直重复(让三个抽烟者轮流地抽烟)

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 10][]

**问题分析：**本质上来说也是属于“生产者-消费者问题”，不同之处在于，属于“可生产多种产品的单生产者-多消费者”问题

1.关系分析

组合一：纸+胶水  
组合二：烟草+胶水  
组合三：烟草+纸

同步关系(从事件的角度来分析) : .  
桌上有组合一  →  第一个抽烟者取走东西  
桌上有组合二  →  第二个抽烟者取走东西  
桌上有组合三  →  第三个抽烟者取走东西  
发出完成信号  →  供应者将下一个组合放到桌上

2.信号量设置

semaphorn offer1=0;   //桌上组合一的数量
    semaphorn offer2=0;   //桌上组合二的数量
    semaphorn offer3=0;   //桌上组合三的数量
    semaphorn finish=0;   //抽烟是否完成
    int i=0;              //用于实现循环

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 11][]

**生产者**

Provider() {
     while(1) {
       if(i==0) {
          将组合一放在桌子上；
          V(offer1);
       }else if(i==1) {
          将组合二放在桌子上；
          V(offer2);
       }else if(i==2) {
          将组合三放在桌子上；
          V(offer3);
       }
       i=(i+1)%3;
       P(finish);
    }

**吸烟者**

smoker1() {
     while(1) {
       P(offer1);
       从桌子上拿走组合一；卷烟；抽掉；
       V(finish);
     }
    }
    
    smoker2() {
     while(1) {
       P(offer2);
       从桌子上拿走组合二；卷烟；抽掉；
       V(finish);
     }
    }
    
    smoker3() {
     while(1) {
       P(offer3);
       从桌子上拿走组合三；卷烟；抽掉；
       V(finish);
     }
    }

# 4.管程 #

**引入原因：**解决信号量机制编程麻烦、易出错的问题

**组成：**共享数据结构、对数据结构初始化语句、访问数据结构的函数、管程名称

**基本特征: 1）**各外部进程/线程只能通过管程提供的特定”入口"才能访问共享数据；**2）**每次仅允许一个进程在管程内执行某个内部过程

**补充：1）**各进程必须互斥访问管程的特性是由编译器实现的；**2）**可在管程中设置条件变量及等待/唤醒操作以解决同步问题

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 12][]

如果有多个生产者进程时，会将后面的生产者进程阻塞，放在由于insert导致的阻塞队列中，在insert最后检查如果是最后一个进程，就唤醒empty阻塞队列中的第一个进程；

如果有多个消费者进程时，会将后面的消费者进程阻塞，放在由于empty或者full导致的阻塞队列中；

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70]: /images/20221022/e8dd97d4aa6345a999391e2404c4c705.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 1]: /images/20221022/8ee17f48cfec44c6aed041b99a842c7f.png
[20210424004303622.png]: /images/20221022/be4b4163eda34e368139bb68be6d1533.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 2]: /images/20221022/c75d45d1e00c44eda2289132c8f28b76.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 3]: /images/20221022/25e70860876f4a86b88c85717800ae7a.png
[2021042401052718.png]: /images/20221022/a0a29797a44d40d694203f5adb0c9d8b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 4]: /images/20221022/6b301d6fed554a70a6ac9e9e09872d36.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 5]: /images/20221022/cc103b5b899f44e393f7e975c833dafd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 6]: /images/20221022/d29803180dbf47bea03f035ad004e81b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 7]: /images/20221022/7ffacf0ce25d4d2885d0d0a8ef64132f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 8]: /images/20221022/1e8223b3341e4026a176300ae5b37ab6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 9]: /images/20221022/d27e2fb999de4e6e9c1abc724b77916c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 10]: /images/20221022/66f59aadf2704692bef12d1c52dce7f5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 11]: /images/20221022/4be7e7c0055e48b98443af4e22f6e05e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzIyMjE3_size_16_color_FFFFFF_t_70 12]: /images/20221022/b74d9d9bde2c4db8bdb80f950e45ba2e.png