Redis的I/O多路复用

骑猪看日落 2023-02-08 12:37 9阅读 0赞

### Redis的I/O多路复用 ###

*   *   *   *   *   *  \[1\] 为什么 Redis 中要使用 I/O 多路复用？
                     *  \[2\] I/O 多路复用模型
                     *  \[3\] select
                     *  \[4\] poll
                     *  \[5\] epoll
                     *  \[6\] Reactor 设计模式
                     *  \[7\] 封装 epoll 函数
                     *  \[8\] select & poll & epoll比较
                     *  \[9\] 深入理解select、poll和epoll及区别：杂文

https://www.jianshu.com/p/311f9d276b2a

###### \[1\] 为什么 Redis 中要使用 I/O 多路复用？ ######

首先，Redis 是跑在单线程中的，所有的操作都是按照顺序线性执行的，但是由于读写操作等待用户输入或输出都是阻塞的，所以 I/O 操作在一般情况下往往不能直接返回，这会导致某一文件的 I/O 阻塞导致整个进程无法对其它客户提供服务，而 I/O 多路复用就是为了解决这个问题而出现的.

**阻塞I/O：**

先来看一下传统的阻塞 I/O 模型到底是如何工作的：当使用 read 或者 write 对某一个文件描述符（File Descriptor 以下简称 FD)进行读写时，如果当前 FD 不可读或不可写，整个 Redis 服务就不会对其它的操作作出响应，导致整个服务不可用.

![img][]

###### \[2\] I/O 多路复用模型 ######

https://blog.csdn.net/wuyangyang555/article/details/82146831

https://blog.csdn.net/wsx199397/article/details/38533239?utm\_medium=distribute.pc\_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.compare&depth\_1-utm\_source=distribute.pc\_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.compare

阻塞式的 I/O 模型并不能满足这里的需求，我们需要一种效率更高的 I/O 模型来支撑 Redis 的多个客户（redis-cli），这里涉及的就是 I/O 多路复用模型了：

**在 I/O 多路复用模型中，最重要的函数调用就是 select，该方法的能够同时监控多个文件描述符的可读可写情况，当其中的某些文件描述符可读或者可写时，select 方法就会返回可读以及可写的文件描述符个数**.

> 与此同时也有其它的 I/O 多路复用函数 epoll/kqueue/evport，它们相比 select 性能更优秀，同时也能支撑更多的服务.
> 
> **文件描述符**：linux下，所有的操作都是对文件进行操作，而对文件的操作是利用[文件描述符][Link 1](file descriptor)来实现的.\*\*每个文件进程控制块中都有一份文件描述符表（可以把它看成是一个数组，里面的元素是指向file结构体指针类型），这个数组的下标就是文件描述符.\*\*在[源代码][Link 2]中，一般用fd作为[文件描述符][Link 1]的标识.
> 
> **套接字**：套接字是一种通信机制，凭借这种机制，客户/服务器系统的开发工作既可以在本地单机上进行，也可以跨网络进行，Linux所提供的功能（如打印服 务，ftp等）通常都是通过套接字来进行通信的，套接字的创建和使用与管道是有区别的，因为套接字明确地将客户和服务器区分出来，套接字可以实现将多个客 户连接到一个服务器.

![img][img 1]

在UNIX系统上，一切皆文件套接字也不例外，每一个套接字都有对应的fd（即文件描述符）我们简单看看这几个系统调用的原型.

###### \[3\] select ######

\*\*select(int nfds， fd\_set \*r， fd\_set \*w，fd\_set *e， struct timeval timeout)*

对于select()，我们需要传3个集合，r（读），w（写）和e其中，r表示我们对哪些fd的可读事件感兴趣，w表示我们对哪些fd的可写事件感兴趣**每个集合其实是一个bitmap，通过0/1表示我们感兴趣的fd**.例如，

如：我们对于fd为6的可读事件感兴趣，那么r集合的第6个bit需要被设置为1这个系统调用会阻塞，直到我们感兴趣的事件（至少一个）发生调用返回时，内核同样使用这3个集合来存放fd实际发生的事件信息也就是说，调用前这3个集合表示我们感兴趣的事件，调用后这3个集合表示实际发生的事件.

select为最早期的UNIX系统调用，它存在4个问题：

1）**这3个bitmap有大小限制**（FD\_SETSIZE，通常为1024）；

2）**由于这3个集合在返回时会被内核修改，因此我们每次调用时都需要重新设置**；

3）**我们在调用完成后需要扫描这3个集合才能知道哪些fd的读/写事件发生了，一般情况下全量集合比较大而实际发生读/写事件的fd比较少，效率比较低下；**

4）**内核在每次调用都需要扫描这3个fd集合，然后查看哪些fd的事件实际发生，在读/写比较稀疏的情况下同样存在效率问题.**

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PMLxfrgy-1596677241241)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200720092539779.png)\]

###### \[4\] poll ######

由于存在这些问题，于是人们对select进行了改进，从而有了poll

poll(struct pollfd *fds， int nfds， inttimeout)
    
    struct pollfd { int fd;short events;short revents;}

poll本质上和select没有区别，它将用户传入的数组拷贝到内核空间，然后查询每个fd对应的设备状态， 但是它没有最大连接数的限制，原因是它是基于链表来存储的.

poll调用需要传递的是一个**pollfd结构的数组**，调用返回时结果信息也存放在这个数组里面pollfd的结构中存放着fd我们对该fd感兴趣的事件(events)以及该fd实际发生的事件(revents)**，poll传递的不是固定大小的bitmap，因此select的问题1解决了**；**poll将感兴趣事件和实际发生事件分开了，因此select的问题2也解决了**但select的问题3和问题4仍然没有解决.

select问题3比较容易解决，只要系统调用返回的是实际发生相应事件的fd集合，我们便不需要扫描全量的fd集合.对于select的问题4，我们为什么需要每次调用都传递全量的fd呢？内核可不可以在第一次调用的时候记录这些fd，然后我们在以后的调用中不需要再传这些fd呢？问题的关键在于**无状态**对于每一次系统调用，内核不会记录下任何信息，所以每次调用都需要重复传递相同信息.

###### \[5\] epoll ######

上帝说要有状态，所以我们有了**epoll**和kqueue

int epoll_create(int size);
    
    int epoll_ctl(int epfd， int op， int fd，struct epoll_event *event);
    
    int epoll_wait(int epfd， struct epoll_event*events， int maxevents， int timeout);

**epoll\_create**的作用是创建一个context，这个context相当于状态保存者的概念

**epoll\_ctl**的作用是，当你对一个新的fd的读/写事件感兴趣时，通过该调用将fd与相应的感兴趣事件更新到context中

**epoll\_wait**的作用是，等待context中fd的事件发生

**epoll的解决方案不像select或poll一样每次都把current（现时发生的）轮流加入fd对应的设备等待队列中，而只在epoll\_ctl时把current挂一遍（这一遍必不可少）并为每个fd指定一个回调函数，当设备就绪，唤醒等待队列上的等待者时，就会调用这个回调函数，而这个回调函数会把就绪的fd加入一个就绪链表**）.epoll\_wait的工作实际上就是在这个就绪链表中查看有没有就绪的fd.

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kak8rSSH-1596677241245)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200720094515533.png)\]

**epoll的两种工作方式：1.水平触发（LT）2.边缘触发（ET）**

*  **LT模式**：若就绪的事件一次没有处理完要做的事件，就会一直去处理.即就会将没有处理完的事件继续放回到就绪队列之中（即那个内核中的链表），一直进行处理.
 *  **ET模式**：就绪的事件只能处理一次，若没有处理完会在下次的其它事件就绪时再进行处理.而若以后再也没有就绪的事件，那么剩余的那部分数据也会随之而丢失.  
    由此可见：ET模式的效率比LT模式的效率要高很多.只是如果使用ET模式，就要保证每次进行数据处理时，要将其处理完，不能造成数据丢失，这样对编写代码的人要求就比较高.  
    注意：ET模式只支持非阻塞的读写：为了保证数据的完整性.

###### \[6\] Reactor 设计模式 ######

Redis 服务采用 Reactor 的方式来实现文件事件处理器（每一个网络连接其实都对应一个文件描述符）

![img][img 2]

![img][img 3]

**文件事件处理器使用 I/O 多路复用模块同时监听多个 FD**，当 accept、read、write 和 close 文件事件产生时，文件事件处理器就会回调 FD 绑定的事件处理器.

虽然整个文件事件处理器是在单线程上运行的，但是通过 I/O 多路复用模块的引入，实现了同时对多个 FD 读写的监控，提高了网络通信模型的性能，同时也可以保证整个 Redis 服务实现的简单.

**I/O 多路复用模块**

I/O 多路复用模块封装了底层的 select、epoll、avport 以及 kqueue 这些 I/O 多路复用函数，为上层提供了相同的接口.

![img][img 4]

在这里我们简单介绍 Redis 是如何包装 select 和 epoll 的，简要了解该模块的功能，整个 I/O 多路复用模块抹平了不同平台上 I/O 多路复用函数的差异性，提供了相同的接口：

*  static int aeApiCreate(aeEventLoop \*eventLoop)
 *  static int aeApiResize(aeEventLoop \*eventLoop， int setsize)
 *  static void aeApiFree(aeEventLoop \*eventLoop)
 *  static int aeApiAddEvent(aeEventLoop \*eventLoop， int fd， int mask)
 *  static void aeApiDelEvent(aeEventLoop \*eventLoop， int fd， int mask)
 *  static int aeApiPoll(aeEventLoop \*eventLoop， struct timeval \*tvp)

同时，因为各个函数所需要的参数不同，我们在每一个子模块内部通过一个 aeApiState 来存储需要的上下文信息：

// select
    typedef struct aeApiState { 
        fd_set rfds， wfds;
        fd_set _rfds， _wfds;
    } aeApiState;
    
    // epoll
    typedef struct aeApiState { 
        int epfd;
        struct epoll_event *events;
    } aeApiState;

这些上下文信息会存储在 eventLoop 的 void \*state 中，不会暴露到上层，只在当前子模块中使用.

封装 select 函数

> select 可以监控 FD 的可读、可写以及出现错误的情况.

在介绍 I/O 多路复用模块如何对 select 函数封装之前，先来看一下 select 函数使用的大致流程：

int fd = /* file descriptor */
    
    fd_set rfds;
    FD_ZERO(&rfds);
    FD_SET(fd， &rfds)
    
    for ( ; ; ) { 
        select(fd+1， &rfds， NULL， NULL， NULL);
        if (FD_ISSET(fd， &rfds)) { 
            /* file descriptor `fd` becomes readable */
        }
    }

1.  初始化一个可读的 fd\_set 集合，保存需要监控可读性的 FD；
2.  使用 FD\_SET 将 fd 加入 rfds；
3.  调用 select 方法监控 rfds 中的 FD 是否可读；
4.  当 select 返回时，检查 FD 的状态并完成对应的操作.

而在 Redis 的 ae\_select 文件中代码的组织顺序也是差不多的，首先在 aeApiCreate 函数中初始化 rfds 和 wfds：

static int aeApiCreate(aeEventLoop *eventLoop) { 
        aeApiState *state = zmalloc(sizeof(aeApiState));
        if (!state) return -1;
        FD_ZERO(&state->rfds);
        FD_ZERO(&state->wfds);
        eventLoop->apidata = state;
        return 0;
    }

而 aeApiAddEvent 和 aeApiDelEvent 会通过 FD\_SET 和 FD\_CLR 修改 fd\_set 中对应 FD 的标志位：

static int aeApiAddEvent(aeEventLoop *eventLoop， int fd， int mask) { 
        aeApiState *state = eventLoop->apidata;
        if (mask & AE_READABLE) FD_SET(fd，&state->rfds);
        if (mask & AE_WRITABLE) FD_SET(fd，&state->wfds);
        return 0;
    }

整个 ae\_select 子模块中最重要的函数就是 aeApiPoll，它是实际调用 select 函数的部分，其作用就是在 I/O 多路复用函数返回时，将对应的 FD 加入 aeEventLoop 的 fired 数组中，并返回事件的个数：

static int aeApiPoll(aeEventLoop *eventLoop， struct timeval *tvp) { 
        aeApiState *state = eventLoop->apidata;
        int retval， j， numevents = 0;
    
        memcpy(&state->_rfds，&state->rfds，sizeof(fd_set));
        memcpy(&state->_wfds，&state->wfds，sizeof(fd_set));
    
        retval = select(eventLoop->maxfd+1，
                    &state->_rfds，&state->_wfds，NULL，tvp);
        if (retval > 0) { 
            for (j = 0; j <= eventLoop->maxfd; j++) { 
                int mask = 0;
                aeFileEvent *fe = &eventLoop->events[j];
    
                if (fe->mask == AE_NONE) continue;
                if (fe->mask & AE_READABLE && FD_ISSET(j，&state->_rfds))
                    mask |= AE_READABLE;
                if (fe->mask & AE_WRITABLE && FD_ISSET(j，&state->_wfds))
                    mask |= AE_WRITABLE;
                eventLoop->fired[numevents].fd = j;
                eventLoop->fired[numevents].mask = mask;
                numevents++;
            }
        }
        return numevents;
    }

###### \[7\] 封装 epoll 函数 ######

Redis 对 epoll 的封装其实也是类似的，使用 epoll\_create 创建 epoll 中使用的 epfd：

static int aeApiCreate(aeEventLoop *eventLoop) { 
        aeApiState *state = zmalloc(sizeof(aeApiState));
    
        if (!state) return -1;
        state->events = zmalloc(sizeof(struct epoll_event)*eventLoop->setsize);
        if (!state->events) { 
            zfree(state);
            return -1;
        }
        state->epfd = epoll_create(1024); /* 1024 is just a hint for the kernel */
        if (state->epfd == -1) { 
            zfree(state->events);
            zfree(state);
            return -1;
        }
        eventLoop->apidata = state;
        return 0;
    }

在 aeApiAddEvent 中使用 epoll\_ctl 向 epfd 中添加需要监控的 FD 以及监听的事件：

static int aeApiAddEvent(aeEventLoop *eventLoop， int fd， int mask) { 
        aeApiState *state = eventLoop->apidata;
        struct epoll_event ee = { 0}; /* avoid valgrind warning */
        /* If the fd was already monitored for some event， we need a MOD * operation. Otherwise we need an ADD operation. */
        int op = eventLoop->events[fd].mask == AE_NONE ?
                EPOLL_CTL_ADD : EPOLL_CTL_MOD;
    
        ee.events = 0;
        mask |= eventLoop->events[fd].mask; /* Merge old events */
        if (mask & AE_READABLE) ee.events |= EPOLLIN;
        if (mask & AE_WRITABLE) ee.events |= EPOLLOUT;
        ee.data.fd = fd;
        if (epoll_ctl(state->epfd，op，fd，&ee) == -1) return -1;
        return 0;
    }

由于 epoll 相比 select 机制略有不同，**在 epoll\_wait 函数返回时并不需要遍历所有的 FD 查看读写情况；在 epoll\_wait 函数返回时会提供一个 epoll\_event 数组**：

typedef union epoll_data { 
        void    *ptr;
        int      fd; /* 文件描述符 */
        uint32_t u32;
        uint64_t u64;} epoll_data_t;
    
    struct epoll_event { 
        uint32_t     events; /* Epoll 事件 */
        epoll_data_t data;
    };

> 其中保存了发生的 epoll 事件（EPOLLIN、EPOLLOUT、EPOLLERR 和 EPOLLHUP）以及发生该事件的 FD.

aeApiPoll 函数只需要将 epoll\_event 数组中存储的信息加入 eventLoop 的 fired 数组中，将信息传递给上层模块：

static int aeApiPoll(aeEventLoop *eventLoop， struct timeval *tvp) { 
        aeApiState *state = eventLoop->apidata;
        int retval， numevents = 0;
    
        retval = epoll_wait(state->epfd，state->events，eventLoop->setsize，
                tvp ? (tvp->tv_sec*1000 + tvp->tv_usec/1000) : -1);
        if (retval > 0) { 
            int j;
    
            numevents = retval;
            for (j = 0; j < numevents; j++) { 
                int mask = 0;
                struct epoll_event *e = state->events+j;
    
                if (e->events & EPOLLIN) mask |= AE_READABLE;
                if (e->events & EPOLLOUT) mask |= AE_WRITABLE;
                if (e->events & EPOLLERR) mask |= AE_WRITABLE;
                if (e->events & EPOLLHUP) mask |= AE_WRITABLE;
                eventLoop->fired[j].fd = e->data.fd;
                eventLoop->fired[j].mask = mask;
            }
        }
        return numevents;
    }

子模块的选择

因为 Redis 需要在多个平台上运行，同时为了最大化执行的效率与性能，所以会根据编译平台的不同选择不同的 I/O 多路复用函数作为子模块，提供给上层统一的接口；在 Redis 中，我们通过宏定义的使用，合理的选择不同的子模块：

#ifdef HAVE_EVPORT#include "ae_evport.c"#else
        #ifdef HAVE_EPOLL
        #include "ae_epoll.c"
        #else
            #ifdef HAVE_KQUEUE
            #include "ae_kqueue.c"
            #else
            #include "ae_select.c"
            #endif
        #endif
    #endif

因为 select 函数是作为 POSIX 标准中的系统调用，在不同版本的操作系统上都会实现，所以将其作为保底方案：

![img][img 5]

Redis 会优先选择时间复杂度为 O(1)的 I/O 多路复用函数作为底层实现，包括 Solaries 10 中的 evport、Linux 中的 epoll 和 macOS/FreeBSD 中的 kqueue，上述的这些函数都使用了内核内部的结构，并且能够服务几十万的文件描述符.

但是如果当前编译环境没有上述函数，就会选择 select 作为备选方案，由于其在使用时会扫描全部监听的描述符，所以其时间复杂度较差 O(n)，并且只能同时服务 1024 个文件描述符，所以一般并不会以 select 作为第一方案使用.

###### \[8\] select & poll & epoll比较 ######

https://www.jianshu.com/p/c8f462827499

https://www.bilibili.com/video/BV1qJ411w7du

**select**： 单个进程所能打开的最大连接数有FD\_SETSIZE宏定义， 其大小为1024或者2048； FD数目剧增后， 会带来性能问题；消息传递从内核到与到用户空间，需要copy数据；  
（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大  
（2）同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rPdvK8jo-1596677241249)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200711143703434.png)\]

**poll**： 基本上与select一样， 不同点在于没有FD数目的限制， 因为底层实现不是一个数组， 而是链表；

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GNQjoP6N-1596677241250)(X:\\Users\\xu\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200711144411018.png)\]

**epoll**： FD连接数虽然有限制， 但是很大几乎可以认为无限制；epoll内核中实现是根据每个fd上的callback函数来实现的，只有活跃的socket才会主动调用callback，所以在活跃socket较少的情况下，使用epoll没有前面两者的线性下降的性能问题； 内核和用户通过共享内存来传递消息；

> **什么是socket？**
> 
> 我们都知道unix(like)世界里，一切皆文件，而文件是什么呢？文件就是一二进制流而已，不管socket，还是FIFO、管道、终端，对我们来说，一切都是文件，一切都是流.在信息 交换的过程中，我们都是对这些流进行数据的收发操作，简称为I/O操作(input and output)，往流中读出数据，系统调用read，写入数据，系统调用write.不过话说回来了 ，计算机里有这么多的流，我怎么知道要操作哪个流呢？对，就是**文件描述符**，即通常所说的fd，一个fd就是一个整数，所以，对这个整数的操作，就是对这个文件（流）的操作.我们创建一个socket，通过系统调用会返回一个文件描述符，那么剩下对socket的操作就会转化为对这个描述符的操作.不能不说这又是一种分层和抽象的思想.
> 
> > *socket*一般指套接字.所谓套接字(*Socket*)，就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象.

linux提供了select、poll、epoll接口来实现IO复用，三者的原型如下所示，本文从参数、实现、性能等方面对三者进行对比.

int select(int nfds， fd_set *readfds， fd_set *writefds， fd_set *exceptfds， struct timeval *timeout);
    int poll(struct pollfd *fds， nfds_t nfds， int timeout);
    int epoll_wait(int epfd， struct epoll_event *events， int maxevents， int timeou);

**select、poll、epoll\_wait参数及实现对比**

1.  **int nfds**：select的第一个参数nfds为fdset集合中最大描述符值加1，fdset是一个位数组，其大小限制为\_\_FD\_SETSIZE（1024），位数组的每一位代表其对应的描述符是否需要被检查.
    
    \*\*fd\_set \*readfds， fd\_set \*writefds， fd\_set \*exceptfds：\*\*select的第二三四个参数表示需要关注读、写、错误事件的文件描述符位数组，这些参数既是输入参数也是输出参数，可能会被内核修改用于标示哪些描述符上发生了关注的事件.所以每次调用select前都需要重新初始化fdset.
    
    \**struct timeval timeout*：timeout参数为超时时间，该结构会被内核修改，其值为超时剩余的时间.
    
    select对应于内核中的sys\_select调用，sys\_select首先将第二三四个参数指向的fd\_set拷贝到内核，然后对每个被SET的描述符调用进行poll，并记录在临时结果中（fdset），如果有事件发生，select会将临时结果写到用户空间并返回；当轮询一遍后没有任何事件发生时，如果指定了超时时间，则select会睡眠到超时，睡眠结束后再进行一次轮询，并将临时结果写到用户空间，然后返回.
    
    **select返回后**，需要逐一检查关注的描述符是否被SET（事件是否发生）.
2.  \*\*struct pollfd \*fds：\*\*poll与select不同，通过一个pollfd数组向内核传递需要关注的事件，故没有描述符个数的限制，pollfd中的events字段和revents分别用于标示关注的事件和发生的事件，故pollfd数组只需要被初始化一次.
    
    poll的实现机制与select类似，其对应内核中的sys\_poll，只不过poll向内核传递pollfd数组，然后对pollfd中的每个描述符进行poll，相比处理fdset来说，poll效率更高.poll返回后，需要对pollfd中的每个元素检查其revents值，来得指事件是否发生.
3.  epoll通过epoll\_create创建一个用于epoll轮询的描述符，通过epoll\_ctl添加/修改/删除事件，通过epoll\_wait检查事件，epoll\_wait的第二个参数用于存放结果.
    
    epoll与select、poll不同，首先，其不用每次调用都向内核拷贝事件描述信息，在第一次调用后，事件信息就会与对应的epoll描述符关联起来.**另外epoll不是通过轮询，而是通过在等待的描述符上注册回调函数，当事件发生时，回调函数负责把发生的事件存储在就绪事件链表中，最后写到用户空间.**
    
    epoll返回后，该参数指向的缓冲区中即为发生的事件，对缓冲区中每个元素进行处理即可，而不需要像poll、select那样进行轮询检查.
    
    **select、poll、epoll\_wait性能对比**  
    select、poll的内部实现机制相似，性能差别主要在于向内核传递参数以及对fdset的位操作上，另外，select存在描述符数的硬限制，不能处理很大的描述符集合.这里主要考察poll与epoll在不同大小描述符集合的情况  
    原文链接：https://blog.csdn.net/leafrenchleaf/article/details/84159301

###### \[9\] 深入理解select、poll和epoll及区别：杂文 ######

https://blog.csdn.net/wteruiycbqqvwt/article/details/90299610

https://blog.csdn.net/nanxiaotao/article/details/90612404?utm\_medium=distribute.pc\_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.compare&depth\_1-utm\_source=distribute.pc\_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.compare

原文链接：https://blog.csdn.net/nanxiaotao/article/details/90612404

[img]: /images/20230208/aa76eb1e6670454ebfe55bc5796d19c7.png
[Link 1]: https://baike.baidu.com/item/%E6%96%87%E4%BB%B6%E6%8F%8F%E8%BF%B0%E7%AC%A6
[Link 2]: https://baike.baidu.com/item/%E6%BA%90%E4%BB%A3%E7%A0%81
[img 1]: /images/20230208/cc7da832cdb54519a139dd1e4bead00c.png
[img 2]: /images/20230208/3be8ae5fa7eb45ae8209e2e14c083ce2.png
[img 3]: /images/20230208/0c843d22380e4a8d91d58380f286918d.png
[img 4]: /images/20230208/f6c4ca282e8a4c7c8ae11028b57cae30.png
[img 5]: https:upload-images.jianshu.io/upload_images/13880925-4f157293d864b83a.png?imageMogr2/auto-orient/strip|imageView2/2/w/1000/format/webp