【计算机网络】Linux下的五种IO模型

ゞ浴缸里的玫瑰 2024-02-19 11:42 64阅读 0赞

#### 目录 ####

*  前言
 *  1.阻塞IO
 *  2.非阻塞IO
 *  3.信号驱动IO
 *  4.异步IO
 *  5.多路转接
 *   *  ①select
     *  ②poll
     *  ③epoll

## 前言 ##

当我们了解了传输层TCP协议的数据缓冲区之后，对用户层的IO就有了一个新的理解，其实用户层调用send等函数发送数据的过程其实是向发送缓冲区中写数据的过程，而调用recvform的过程其实就是向接收缓冲区中读取的过程。而真正什么时候发送数据以及怎么发数据其实是由传输层决定的，即由OS来决定的。

**因此我们发现我们所说的IO其实就是缓冲区的读写**，而缓冲区的读写的过程分为两个内容：**等待+拷贝数据**。当缓冲区数据就绪的时候，应用层就可以从缓冲区中拷贝数据或者向缓冲区中发送数据了；当缓冲区没有就绪的时候就需要应用层来进行等待了。

## 1.阻塞IO ##

当没有输入内容可以疏导进程程序时，进行阻塞等待

进程程序调用read读取套接字（文件）内容，如果套接字没有数据可读，阻塞等待

如果写（输出）的数据量很大， 但是没有那么大的缓冲去可写，就阻塞等待

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

#include <sys/types.h>          
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <string.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
     
     
    int main()
    {
        
    	
    	//TCP服务端
    	//1、创建套接字
    	int sockfd = socket(AF_INET,SOCK_STREAM,0);
    	//2、绑定套接字
    	struct sockaddr_in serveraddr;
    	serveraddr.sin_family = AF_INET;
    	serveraddr.sin_port = htons(9999);
    	serveraddr.sin_addr.s_addr = inet_addr("192.168.124.63");
    	bind(sockfd,(struct sockaddr *)&serveraddr,sizeof(serveraddr));
    	//3、监听套接字
    	listen(sockfd,10);
    	//4、接收（同意）套接字
    	int client[3];
    	for(int i = 0; i < 3 ;i++)	
    	{
        
    		client[i] = accept(sockfd,NULL,NULL);
    	}
    	printf("ok\n");
    	
    	//阻塞IO操作
    	while(1)
    	{
        
    		char buf[20];
    		memset(buf,0,20);
    		read(client[0],buf,20);
    		printf("0 is %s\n",buf);
     
    		memset(buf,0,20);
    		read(client[1],buf,20);
    		printf("1 is %s\n",buf);
    	
    		memset(buf,0,20);
    		read(client[2],buf,20);
    		printf("2 is %s\n",buf);
    	}
     
     
    	return 0;
    }

## 2.非阻塞IO ##

当进程进行IO操作（请求）——read、write时，进程通知内核，如果不能立即完成IO（读、写）操作，就立即结束返回，不进行本次IO操作。

默认一般都是阻塞IO，通过函数功能（fcnt()）来实现原来的阻塞IO变成非阻塞IO，设置文件描述符（套接字）的属性为非阻塞。

fcnt()进行设置：先获取文件描述符的状态属性，修改对应的属性状态值，再设置回文件描述符1

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

#include <iostream>
    #include <unistd.h>
    #include <fcntl.h>
    #include <cstdio>
    #include <cstring>
    #include<vector>
    #include<functional>
    
    using func_t =std::function<void(void)>;
    std::vector<func_t> funcs;
    
    void printLog()
    {
        
        std::cout<<"这是一个日志任务"<<std::endl;
    }
    
    void OperMysql()
    {
        
        std::cout<<"这是一个数据库任务"<<std::endl;
    }
    
    void CheckNet()
    {
        
        std::cout<<"这是一个检测网络状态任务"<<std::endl;
    }
    
    void LoatTask()
    {
        
        funcs.push_back(printLog);
        funcs.push_back(OperMysql);
        funcs.push_back(CheckNet);
    }
    
    void HandlerAllTask()
    {
        
        for(const auto&func:funcs)func();
    }
    
    void SetNonBlock(int fd)
    {
        
        int fl = fcntl(fd, F_GETFL);
        if (fl == -1)
        {
        
            std::cerr << "error string: " << strerror(errno) << "error code: " << errno << std::endl;
            return;
        }
        fcntl(fd, F_SETFL, fl | O_NONBLOCK); // 设置非阻塞
    }
    
    int main()
    {
        
        char buffer[64];
        SetNonBlock(0); // 标准输入设置非阻塞
        LoatTask();
        while (true)
        {
        
            std::cout << ">>>" << std::endl;
            fflush(stdout);
            ssize_t n = read(0, buffer, sizeof(buffer) - 1);
            // 1.成功 2.结束 3.出错（一旦底层没有数据就绪，就以出错的形式返回，但不算真正的错误）
            if (n > 0)
            {
        
                buffer[n - 1] = 0;
                std::cout << "echo# " << buffer << std::endl;
            }
            else if (n == 0)
            {
        
                std::cout << "end file" << std::endl;
                break;
            }
            else
            {
        
                // 一旦fd被设置为非阻塞
                if (errno == EAGAIN || errno == EWOULDBLOCK)
                {
        
                    // 底层数据没有就绪，下次再继续检测
                    HandlerAllTask();
                    std::cout << "data not ready" << std::endl;
                    sleep(1);
                    continue;
                }
                else if (errno == EINTR)
                {
        
                    // 这次IO被信号中断，也需要重新读取
                    continue;
                }
                else
                {
        
                    std::cerr << "read fail? "
                              << "error string: " << strerror(errno) << "error code: " << errno << std::endl;
                    break;
                }
            }
        }
    
        return 0;
    }

## 3.信号驱动IO ##

信号驱动IO不是像select采用轮询的方式来监控多个fd的，通过不断的轮询fd的可读状态来知道是否有可读的数据，而是在调用sigaction时候建立一个SIGIO的信号联系，当内核数据准备好之后再通过SIGIO信号通知线程数据准备好后的可读状态，当线程收到可读状态的信号后，此时再向内核发起recvfrom读取数据的请求，因为信号驱动IO的模型下应用线程在发出信号监控后即可返回，不会阻塞，所以这样的方式下，一个应用线程也可以同时监控多个fd。  
![在这里插入图片描述][10a4d002221d494bb86de43f3ec9dca7.png]

一般通过如下 6 个步骤来使用信号驱动式 I/O 模型。

**1.为通知信号处理函数：****通过 sigaction() 来完成**

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

**2.为文件描述符设置属性：****通过 fcntl() 的 F\_SETOWN 操作来完成**

fcntl(fd, F_SETOWN, pid)

**3.设置非阻塞：****通过 fcntl() 的 F\_SETFL 操作来完成**

flags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);

**4.设置信号驱动：****通过 fcntl() 的 F\_SETFL 操作来完成**

flags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, flags | O_ASYNC);

**5.进程等待IO信号的到来**

当 I/O 操作就绪时，内核会给进程发送一个信号，然后调用在第 1 步中安装好的信号处理函数。

**5.进程执行IO操作**

循环执行 I/O 系统调用直到失败为止，此时错误码为 EAGAIN 或 EWOULDBLOCK。

**原因：**

信号驱动 I/O 提供的是边缘触发通知，即只有当 I/O 事件发生时我们才会收到通知，

且当文件描述符收到 I/O 事件通知时，并不知道要处理多少 I/O 数据。

## 4.异步IO ##

> 异步IO模型只需要向内核发送一个read请求,告诉内核它要读取数据后即刻返回；内核收到请求后会建立一个信号联系，当数据准备就绪，内核会主动把数据从内核复制到用户空间，等所有操作都完成之后，内核会发起一个通知告诉应用。  
> ![在这里插入图片描述][8cee498559c44aec8e2def98d4390b94.png]

## 5.多路转接 ##

同时管理多个IO（文件描述符），当某个或多个文件描述符可以进行通信（可以执行输入输出IO操作），得到对应的文件描述符去进行读写IO操作  
![在这里插入图片描述][28b969fca23f44b3ab9194b7ba9b9b3f.png]

### ①select ###

> （1）构造列表： 首先要构造一个关于文件描述符的列表（需要监听的），列表数据类型为 fd\_set，它是一个整型数组，总共是 1024  
> 个比特位，每一个比特位代表一个文件描述符的状态。
> 
> （2）检测事件：调用 select() 。监听该列表中的文件描述符的事件，函数返回并修改文件描述符的列表中对应的值，0  
> 表示没有检测到该事件，1 表示检测到该事件。检测的操作是由内核完成的。
> 
> （3）进行I/O 操作 ： select() 返回时告诉进程有多少描述符要进行 I/O 操作，接下来遍历文件描述符的列表进行 I/O操作。

**接口：**

>     int select(int nfds, fd_set *readfds, fd_set *writefds,
>                       fd_set *exceptfds, struct timeval *timeout);

> **ndfs**:等待的文件描述符的最大值+1，例如：应用进程想要去等待文件描述符3,5,8的事件，则nfds=max(3,5,8)+1;  
>   
> **fd\_set**:readfds和writefds，exceptfds的类型都是fd\_set,那么fd\_set类型是什么呢？  
>   
> **fd\_set类型本质是一个位图**，位图的位置 表示 相对应的文件描述符，内容表示该文件描述符是否有效，1代表该位置的文件描述符有效，0则表示该位置的文件描述符无效。  
> 如果将文件描述符2，3设置位图当中，则位图表示的是为1100。  
>   
> fd\_set的上限是1024个文件描述符。  
>   
> **readfds**:readfds是 等待读事件的文件描述符集合，.如果不关心读事件（缓冲区有数据)，则可以传NULL值。 应用进程和内核都可以设置readfds，应用进程设置readfds是为了通知内核去等待readfds中的文件描述符的读事件.而  
> 内核设置readfds是为了告诉应用进程哪些读事件生效  
>   
> **writefds**:与readfds类似，writefds是等待写事件(缓冲区中是否有空间)的集合，如果不关心写事件，则可以传值NULL。  
>   
> **exceptfds**:如果内核等待相应的文件描述符发生异常，则将失败的文件描述符设置进exceptfds中，如果不关心错误事件，可以传值NULL。  
>   
> **timeout**:设置select在内核中阻塞的时间，如果想要设置为非阻塞，则设置为NULL。如果想让select阻塞5秒，则将创建一个struct  
> timeval time=\{5,0\};
> 
> 其中struct timeval的结构体类型是：
> 
>     struct timeval {
>          
>                    long    tv_sec;         /* seconds */
>                    long    tv_usec;        /* microseconds */
>                };
> 
> **返回值:**  
> 如果没有文件描述符就绪就返回0；  
> 如果调用失败返回-1；  
> 如果timeout中中readfds中有事件发生，则返回timeout剩下的时间。

**缺点：**

> （1）开销大：调用select，需要把 fd 集合从用户态拷贝到内核态，需要在内核遍历传递进来的所有 fd，这个开销在 fd 很多时很大；
> 
> （2）支持数量少 ：select 支持的文件描述符数量太小了，默认是 1024（由 fd\_set 决定）；
> 
> （3）文件描述符集合不能重用，因为内核每次检测到事件都会修改，所以每次都需要重置；
> 
> （4）定位不深 ：每次 select 返回后，只能知道有几个 fd 发生了事件，但是具体哪几个还需要遍历文件描述符集合进一步判断

**使用select实现一个简单的服务器**

Sock.hpp

1 #pragma once                                                                                                                        
      2 
      3 
      4 #include <iostream>
      5 #include <string>
      6 
      7 #include <sys/socket.h>
      8 #include <netinet/in.h>
      9 #include <sys/types.h>
     10 #include <arpa/inet.h>
     11 #include <unistd.h>
     12 #include <stdlib.h>
     13 #include <strings.h>
     14 #include <sys/select.h>
     15 
     16 using namespace std;
     17 
     18 class Sock{
        
     19     public:
     20       static int Socket(){
        
     21           int sock = socket(AF_INET, SOCK_STREAM, 0);
     22               if(sock < 0){
        
     23               cerr << "socket error" << endl;
     24               exit(2);
     25               }
     26           return sock;
     27 }
     28     static void Bind(int sock, int port){
        
     29           struct sockaddr_in local;
     30           bzero(&local, sizeof(local));
     31 
     32           local.sin_family = AF_INET;
     33           local.sin_port = htons(port);
     34           local.sin_addr.s_addr = htonl(INADDR_ANY);
     35           if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0){
        
     36             cerr << "bind error" << endl;
     37             exit(3);
     38           }
     39                                                                                               
     40 }
     41     static void Listen(int sock){
        
     42         if(listen(sock, 5) < 0){
        
     43         cerr << "listen error" << endl;
     44         exit(4);
     45         }
     46                                           
     47 }
     48     static int Accept(int sock){
        
     49         struct sockaddr_in peer;
     50         socklen_t len = sizeof(peer);
     51         int fd = accept(sock, (struct sockaddr*)&peer, &len);
     52           if(fd < 0){
        
     53               cerr << "accpet error" << endl;
     54           }
     55 
     56         return fd;
     57         }
     58     static void Setsockopt(int sock){
        
     59         int opt = 1;
     60         setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
     61     }
     62 };

selectServer.hpp

#pragma once                                                                                                                      
         
         #include"Sock.hpp"
         #include<sys/select.h>
         #define NUM (sizeof(fd_set)*8)
         #define DFL_FD -1
         
         
         //#define DFL_PORT 8080
        #define NUM (sizeof(fd_set)*8)
        #define DFL_FD -1
        
        class SelectServer {
        
          private:
                int lsock; 
                int port;
                int fd_array[NUM];
          public:
              SelectServer(int _p = 8080) :port(_p)
              {
        }
             void InitServer(){
        
               //初始化数组来保存已经打开的文件描述符
              for (int i = 0; i < NUM; i++) {
        
                    fd_array[i] = DFL_FD;                            
                    }
                lsock = Sock::Socket();
                Sock::Setsockopt(lsock);
                Sock::Bind(lsock, port);
                Sock::Listen(lsock);
               
                fd_array[0] = lsock;//将第一个元素设置成监听套接字
        }
             void AddFd2Array(int sock){
        
                  int i = 0;
               for (; i < NUM; i++){
        
                  if (fd_array[i] == DFL_FD) {
          
                     break;
                     }
                  }
                if (i >= NUM) {
        
                    cerr << "fd array is full, close sock" << endl;
                    close(sock);
                  }
                  else{
        
                    fd_array[i] = sock;
                    cout << "fd: " << sock << " add to select ..." << endl;
                                                                                
                  }
                                                  
        }
             void DefFdFromArray(int index){
        
                  if (index >= 0 && index < NUM){
        
                      fd_array[index] = DFL_FD;
                                                                
                      }
        }
            void HandlerEvents(fd_set* rfds){
        
              //先判断文件描述符是否合法
               for (int i = 0; i < NUM; i++){
        
                      if(fd_array[i] == DFL_FD){
        
                         continue;                                                     
                      }//分为监听套接字和普通的套接字
                      if(FD_ISSET(fd_array[i], rfds)) {
        
                           if (fd_array[i] == lsock) {
        
                                                                                                                                          
                          int sock = Sock::Accept(lsock);
                              if (sock >= 0){
                                                                           
                                cout << "get a new link ..." << endl;
                                AddFd2Array(sock);//监听套接字不能直接就读数据，要先添加到数组中
                                                  //有可能连接建立好后不发数据了
                              }
                                                                                        
                            }
                      else{
                        
                            char buf[10240];
                            ssize_t s = recv(fd_array[i], buf, sizeof(buf), 0);
                            if (s > 0) {
        
                                buf[s] = 0;
                                cout << "client# " << buf << endl;
                                                                                                                                                                   
                     else if (s == 0) {
        
                             cout << "clien quit" << endl;
                             //客户端退出关闭文件描述符和将位图中的清0
                             close(fd_array[i]);  
                             DefFdFromArray(i);}
                     else {
        }
                     }
                   }
                                                        
                 }
        }
              void Start(){
        
                   int maxfd = DFL_FD;
                   for (;;) {
        
                        fd_set rfds;
                        FD_ZERO(&rfds);//在栈上先将位图清0
                        cout << "fd_array: ";
                     for (int i = 0; i < NUM; i++) {
        
                           if (fd_array[i] != DFL_FD) {
                                                                                          
                          cout << fd_array[i] << " ";
                           FD_SET(fd_array[i], &rfds);
                           if (maxfd < fd_array[i]){
        
                             maxfd = fd_array[i];//更新最大的maxfd
                           }
                         }
                      }
                       cout << endl;
                       cout << "begin select ..." << endl;
                       switch (select(maxfd + 1, &rfds, nullptr, nullptr, nullptr)){
        
                         //select的3种返回值
                         case 0:
                            cout << "timeout ..." << endl; 
                            break;
                         case -1:        
                            cerr << "select error!" << endl; 
                            break; 
                         default:
                            //事件就绪
                            HandlerEvents(&rfds);
                            break;
                       }
                 }
       }
            ~SelectServer()
           {
        }
       
       };

select.cc

1 #include "selectServer.hpp"
      2                                                                                                                                     
      3 void Usage(string proc)
      4 {
        
      5       cout <<"Usage:\n\t"<< proc << " port" << endl;
      6 
      7 }
      8 
      9 int main(int argc, char *argv[])
     10 {
        
     11   cout << sizeof(fd_set)*8 << endl;
     12   if(argc != 2)
     13   {
        
     14      Usage(argv[0]);
     15      exit(1);
     16   }
     17   SelectServer *ssvr = new SelectServer(atoi(argv[1]));
     18   ssvr->InitServer();
     19   ssvr->Start();
     20 
     21    return 0;
     22 }

### ②poll ###

用一个文件描述符集合，每次只轮询一个集合，也是返回事件个数(只返回个数)，效率比select高。poll支持的文件描述符没有限制，实现原理和select类似。

**接口**

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

**参数：**

*  fds是一个poll函数监听的结构列表. 每一个元素中, 包含了三部分内容: 文件描述符, 监听的事件集合, 返回的事件集合.
 *  nfds表示fds数组的长度.
 *  timeout表示poll函数的超时时间, 单位是毫秒(ms)

**pollfd结构:**

struct pollfd {
        
     int fd; /* file descriptor */
     short events; /* requested events */
     short revents; /* returned events */
    };

**events和revents**  
![在这里插入图片描述][79fe1d95d40141519874dcd20e3ac453.png]

**返回值**

*  返回值小于0, 表示出错;
 *  返回值等于0, 表示poll函数等待超时;
 *  返回值大于0, 表示poll由于监听的文件描述符就绪而返回

**poll的优点：**

*  pollfd结构包含了要监视的event和发生的event，不再使用select“参数-值”传递的方式. 接口使用比select更方便.
 *  poll并没有最大数量限制 (但是数量过大后性能也是会下降).

**poll的缺点**

*  和select函数一样，poll返回后，需要轮询pollfd来获取就绪的描述符.
 *  每次调用poll都需要把大量的pollfd结构从用户态拷贝到内核中.
 *  同时连接的大量客户端在一时刻可能只有很少的处于就绪状态, 因此随着监视的描述符数量的增长, 其效率也会线性下降.

### ③epoll ###

**epoll 核心的两个数据结构：红黑树和就绪列表。** 红黑树是为了应对用户的增删改需求，就绪列表是 fd 事件就绪之后放置的特殊地点，epoll 池只需要遍历这个就绪链表，就能给用户返回所有已经就绪的 fd 数组；红黑树是一种平衡二叉树，时间复杂度为 O(log n)，就算这个池子就算不断的增删改，也能保持非常稳定的查找性能。**epoll还有回调机制**。在某个文件描述符的哪个事件就绪后，可以通过回调机制将就绪的文件描述符结构添加到就绪队列，不用再去遍历存储文件描述符的数据结构。

**epoll是一种更加高效的IO复用技术。**  
![在这里插入图片描述][44a51e51abf84c61871f6808f0124ff9.png]

*  当进程调用epoll\_create时，内核创建一个红黑树，红黑树的结点包含对应的事件，重复添加的事件就可以通过红黑树而高效的识别出来(红黑树的插入时间效率是lgn，其中n为树的高度)  
    而所有添加到epoll中的事件都会与设备(网卡)驱动程序建立回调关系，也就是说，当响应的事件发生时会调用这个回调方法，这个回调方法在内核中叫ep\_poll\_callback,它会将发生的事件添加到就绪队列中
 *  在epoll中，对于每一个事件，都会建立一个epitem结构体.
 *  epoll\_ctrl将要监控的文件描述符进行注册;
 *  epoll\_wait, 则把发生的事件复制到用户态，同时将事件数量返回给用户. 这个操作的时间复杂度  
    是O(1).只需检查就绪队列是否有结点。

**epoll的优点**

*  **接口使用方便:** 虽然拆分成了三个函数, 但是反而使用起来更方便高效. 不需要每次循环都设置关注的文件描述符, 也做到了输入输出参数分离开
 *  **数据拷贝轻量:** 只在合适的时候调用 EPOLL\_CTL\_ADD 将文件描述符结构拷贝到内核中, 这个操作并不频繁(而select/poll都是每次循环都要进行拷贝)
 *  **事件回调机制:** 避免使用遍历, 而是使用回调函数的方式, 将就绪的文件描述符结构加入到就绪队列中, epoll\_wait 返回直接访问就绪队列就知道哪些文件描述符就绪. 这个操作时间复杂度O(1). 即使文件描述符数目很多, 效率也不会受到影响.
 *  **没有数量限制:** 文件描述符数目无上限

**epoll的工作模式**

**epoll有2种工作方式-水平触发(LT)和边缘触发(ET)**

> 水平触发Level Triggered 工作模式

epoll默认状态下就是LT工作模式.

*  当epoll检测到socket上事件就绪的时候, 可以不立刻进行处理. 或者只处理一部分.  
    例：只读了1K数据, 缓冲区中还剩1K数据, 在第二次调用 epoll\_wait 时, epoll\_wait仍然会立刻返回并通知socket读事件就绪.
 *  直到缓冲区上所有的数据都被处理完, epoll\_wait 才不会立刻返回.
 *  支持阻塞读写和非阻塞读写

> 边缘触发Edge Triggered工作模式

如果我们在第1步将socket添加到epoll描述符的时候使用了EPOLLET标志, epoll进入ET工作模式.

*  当epoll检测到socket上事件就绪时, 必须立刻处理
 *  如上面的例子, 虽然只读了1K的数据, 缓冲区还剩1K的数据, 在第二次调用 epoll\_wait 的时候, epoll\_wait 不会再返回了
 *  也就是说, ET模式下, 文件描述符上的事件就绪后, 只有一次处理机会
 *  ET的性能比LT性能更高( epoll\_wait 返回的次数少了很多). Nginx默认采用ET模式使用epoll.
 *  只支持非阻塞的读写

select和poll其实也是工作在LT模式下. epoll既可以支持LT, 也可以支持ET,在ET模式下必须要将fd设置位非阻塞.

[a98bf19cd24d462b815f716373db188f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/df5a4d8a542f493e938b05a13f3cac98.png
[819dcb8b0ec74d2ba10eb7377d70bd27.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/d51152e1e5e34ead8109e81ee8dba37d.png
[10a4d002221d494bb86de43f3ec9dca7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/bc3cc741c6824e49bdc5ee2cf82e8f1b.png
[8cee498559c44aec8e2def98d4390b94.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/92fb4da8299440f2a6c88bf339615e8a.png
[28b969fca23f44b3ab9194b7ba9b9b3f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/a425257e283f419d85e99b2efa1f4d10.png
[79fe1d95d40141519874dcd20e3ac453.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/cf2f96e569114761a53267d9ff847092.png
[44a51e51abf84c61871f6808f0124ff9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/7e3d10505e02497ab57458da1c917db2.png