Libevent源码分析-----Libevent工作流程探究

素颜马尾好姑娘i 2022-05-09 07:24 284阅读 0赞

之前的博文讲了很多Libevent的基础构件，现在以一个实际例子来初步探究Libevent的基本工作流程。由于还有很多Libevent的细节并没有讲所以，这里的探究还是比较简洁，例子也相当简单。

#include<unistd.h>
    
    #include<stdio.h>
    
    #include<event.h>
    
    #include<thread.h>
    
    
    
    void cmd_cb(int fd, short events, void *arg)
    
    {
    
    char buf[1024];
    
    printf("in the cmd_cb\n");
    
    
    read(fd, buf, sizeof(buf));
    
    }
    
    
    
    int main()
    
    {
    
    evthread_use_pthreads();
    
    
    //使用默认的event_base配置
    
    struct event_base *base = event_base_new();
    
    
    struct event *cmd_ev = event_new(base, STDIN_FILENO,
    
    EV_READ | EV_PERSIST, cmd_cb, NULL);
    
    
    event_add(cmd_ev, NULL); //没有超时
    
    
    event_base_dispatch(base);
    
    
    return 0;
    
    }

上面代码估计是不会比读者写的第一个Libevent程序复杂。但这已经包含了Libevent的基础工作流程。这里将进入这些函数的内部探究，并且只会讲解之前博文出现过的，没出现的，尽量不讲。在讲解之前，要先了解一下struct event这个结构体。

struct event {
    
    TAILQ_ENTRY(event) ev_active_next; //激活队列
    
    TAILQ_ENTRY(event) ev_next; //注册事件队列
    
    /* for managing timeouts */
    
    union {
    
    TAILQ_ENTRY(event) ev_next_with_common_timeout;
    
    int min_heap_idx; //指明该event结构体在堆的位置
    
    } ev_timeout_pos; //仅用于定时事件处理器(event).EV_TIMEOUT类型
    
    
    //对于I/O事件，是文件描述符；对于signal事件，是信号值
    
    evutil_socket_t ev_fd;
    
    
    struct event_base *ev_base; //所属的event_base
    
    
    //因为信号和I/O是不能同时设置的。所以可以使用共用体以省内存
    
    //在低版本的Libevent，两者是分开的，不在共用体内。
    
    union {
    
    //无论是信号还是IO，都有一个TAILQ_ENTRY的队列。它用于这样的情景:
    
    //用户对同一个fd调用event_new多次，并且都使用了不同的回调函数。
    
    //每次调用event_new都会产生一个event*。这个xxx_next成员就是把这些
    
    //event连接起来的。
    
    
    /* used for io events */
    
    //用于IO事件
    
    struct {
    
    TAILQ_ENTRY(event) ev_io_next;
    
    struct timeval ev_timeout;
    
    } ev_io;
    
    
    /* used by signal events */
    
    //用于信号事件
    
    struct {
    
    TAILQ_ENTRY(event) ev_signal_next;
    
    short ev_ncalls; //事件就绪执行时，调用ev_callback的次数 /* Allows deletes in callback */
    
    short *ev_pncalls; //指针，指向次数
    
    } ev_signal;
    
    } _ev;
    
    
    short ev_events;//记录监听的事件类型 EV_READ EVTIMEOUT之类
    
    short ev_res; /* result passed to event callback *///记录了当前激活事件的类型
    
    //libevent用于标记event信息的字段，表明其当前的状态.
    
    //可能值为前面的EVLIST_XXX
    
    short ev_flags;
    
    
    //本event的优先级。调用event_priority_set设置
    
    ev_uint8_t ev_pri;
    
    ev_uint8_t ev_closure;
    
    struct timeval ev_timeout;//用于定时器,指定定时器的超时值
    
    
    /* allows us to adopt for different types of events */
    
    void (*ev_callback)(evutil_socket_t, short, void *arg); //回调函数
    
    void *ev_arg; //回调函数的参数
    
    };

event结构体里面有几个TAILQ\_ENTRY队列节点类型。这里因为一个event是会同时处于多个队列之中。比如前几篇博文说到的同一个文件描述符或者信号值对应的多个event会被连在一起，所有的被加入到event\_base的event也会连在一起，所有被激活的event也会被连在一起。所以会有多个QAILQ\_ENTRY。

event结构体只有一两个之前没有说到的概念，这不妨碍理解event结构体。而event\_base结构体则会太多之前没有说到的概念，所以这里就不贴出event\_base的代码了。

在读这篇博文前，最好读一下前面几篇博文，因为会用到其他讲到的东西。如果之前有讲过的东西，这里也将一笔带过。

好了，开始探究。

最前面的evthread\_use\_pthreads();就不多说了，看《[多线程、锁、条件变量(一)][Link 1]》和《[多线程、锁、条件变量(二)][Link 2]》这两篇博文吧。

# 创建event\_base： #

下面看一下event\_base\_new函数。它是由event\_base\_new\_with\_config函数实现的。我们还是看后面那个函数吧。

//event.c文件
    
    struct event_base *
    
    event_base_new_with_config(const struct event_config *cfg)
    
    {
    
    int i;
    
    struct event_base *base;
    
    int should_check_environment;
    
    
    
    //之所以不用mm_malloc是因为mm_malloc并不会清零该内存区域。
    
    //而这个函数是会清零申请到的内存区域，这相当于被base初始化
    
    if ((base = mm_calloc(1, sizeof(struct event_base))) == NULL) {
    
    event_warn("%s: calloc", __func__);
    
    return NULL;
    
    }
    
    
    ...
    
    
    TAILQ_INIT(&base->eventqueue);
    
    
    ...
    
    
    if (cfg)
    
    base->flags = cfg->flags;
    
    
    evmap_io_initmap(&base->io);
    
    evmap_signal_initmap(&base->sigmap);
    
    
    base->evbase = NULL;
    
    
    should_check_environment =
    
    !(cfg && (cfg->flags & EVENT_BASE_FLAG_IGNORE_ENV));
    
    
    //选择IO复用结构体
    
    for (i = 0; eventops[i] && !base->evbase; i++) {
    
    if (cfg != NULL) {
    
    /* determine if this backend should be avoided */
    
    if (event_config_is_avoided_method(cfg,
    
    eventops[i]->name))
    
    continue;
    
    if ((eventops[i]->features & cfg->require_features)
    
    != cfg->require_features)
    
    continue;
    
    }
    
    
    if (should_check_environment &&
    
    event_is_method_disabled(eventops[i]->name))
    
    continue;
    
    
    //找到一个满足条件的多路IO复用函数
    
    base->evsel = eventops[i];
    
    
    //初始化ev_base。并且会对信号监听的处理也进行初始化
    
    base->evbase = base->evsel->init(base);
    
    }
    
    
    
    
    #ifndef _EVENT_DISABLE_THREAD_SUPPORT
    
    //测试evthread_lock_callbacks结构中的lock指针函数是否为NULL
    
    //即测试Libevent是否已经初始化为支持多线程模式。
    
    //由于一开始是用mm_calloc申请内存的，所以该内存区域的值为0
    
    //对于th_base_lock变量，目前的值为NULL.
    
    if (EVTHREAD_LOCKING_ENABLED() &&
    
    (!cfg || !(cfg->flags & EVENT_BASE_FLAG_NOLOCK))) { //配置是支持锁的
    
    EVTHREAD_ALLOC_LOCK(base->th_base_lock,
    
    EVTHREAD_LOCKTYPE_RECURSIVE); //申请一个锁
    
    base->defer_queue.lock = base->th_base_lock;
    
    EVTHREAD_ALLOC_COND(base->current_event_cond);//申请一个条件变量
    
    }
    
    #endif
    
    
    return (base);
    
    }

这里用到了event\_config结构体，关于这个结构体可以参考《[配置event\_base》][event_base]一文。这个结构体主要是对event\_base进行一些配置。另外代码中还讲到了怎么使用选择一个多IO复用函数，这个可以参考《[跨平台Reactor接口的实现][Reactor]》一文。

宏EVTHREAD\_LOCKING\_ENABLED主要是检测是否已经支持锁了。检测的方式也很简单，也就是检测\_evthread\_lock\_fns全局变量中的lock成员变量是否不为NULL。有关这个\_evthread\_lock\_fns全局变量可以查看《[多线程、锁、条件变量(一)][Link 1]》。

# 创建event： #

好了，现在event\_base已经新建出来了。下面看一下event\_new函数，它和前面的event\_base\_new一样，把主要是的初始化工作交给另一个函数。event\_new函数的工作只是创建一个struct event结构体，然后把它的参数原封不动地传给event\_assign，所以还是看event\_assign函数。

//event.c文件
    
    int
    
    event_assign(struct event *ev, struct event_base *base, evutil_socket_t fd,
    
    short events, void (*callback)(evutil_socket_t, short, void *), void *arg)
    
    {
    
    //进行一些赋值和初始化。
    
    ev->ev_base = base;
    
    ev->ev_callback = callback;
    
    ev->ev_arg = arg;
    
    ev->ev_fd = fd;
    
    ev->ev_events = events;
    
    ev->ev_res = 0;
    
    ev->ev_flags = EVLIST_INIT; //初始化状态
    
    ev->ev_ncalls = 0;
    
    ev->ev_pncalls = NULL;
    
    
    if (events & EV_SIGNAL) {
    
    if ((events & (EV_READ|EV_WRITE)) != 0) {
    
    event_warnx("%s: EV_SIGNAL is not compatible with "
    
    "EV_READ or EV_WRITE", __func__);
    
    return -1;
    
    }
    
    }
    
    
    ...
    
    
    return 0;
    
    }

从event\_assign函数的名字可以得知它是进行赋值操作的。所以它能可以在event被初始化后再次调用。不过，初始化后再次调用的话，有些事情要注意。这个在后面的博客中会说到。

从上面的代码可看到：如果这个event是用来监听一个信号的，那么就不能让这个event监听读或者写事件。原因是其与信号event的实现方法相抵触，具体可以参考《[信号event的处理][event]》。

注意，此时event结构体的变量ev\_flags的值是EVLIST\_INIT。对变量的追踪是很有帮助的。它指明了event结构体的状态。它通过以或运算的方式取下面的值：

//event_struct.h文件
    
    #define EVLIST_TIMEOUT 0x01 //event从属于定时器队列或者时间堆
    
    #define EVLIST_INSERTED 0x02 //event从属于注册队列
    
    #define EVLIST_SIGNAL 0x04 //没有使用
    
    #define EVLIST_ACTIVE 0x08 //event从属于活动队列
    
    #define EVLIST_INTERNAL 0x10 //该event是内部使用的。信号处理时有用到
    
    #define EVLIST_INIT 0x80 //event已经被初始化了
    
    
    /* EVLIST_X_ Private space: 0x1000-0xf000 */
    
    #define EVLIST_ALL (0xf000 | 0x9f) //所有标志。这个不能取

# 将event加入到event\_base中： #

创建完一个event结构体后，现在看一下event\_add。它同前面的函数一样，内部也是调用其他函数完成工作。因为它用到了锁，所以给出它的代码

//event.c文件
    
    int
    
    event_add(struct event *ev, const struct timeval *tv)
    
    {
    
    int res;
    
    
    //加锁
    
    EVBASE_ACQUIRE_LOCK(ev->ev_base, th_base_lock);
    
    res = event_add_internal(ev, tv, 0);
    
    //解锁
    
    EVBASE_RELEASE_LOCK(ev->ev_base, th_base_lock);
    
    return (res);
    
    }
    
    
    static inline int
    
    event_add_internal(struct event *ev, const struct timeval *tv,
    
    int tv_is_absolute)
    
    {
    
    struct event_base *base = ev->ev_base;
    
    int res = 0;
    
    int notify = 0;
    
    ...
    
    if ((ev->ev_events & (EV_READ|EV_WRITE|EV_SIGNAL)) &&
    
    !(ev->ev_flags & (EVLIST_INSERTED|EVLIST_ACTIVE))) {
    
    if (ev->ev_events & (EV_READ|EV_WRITE))
    
    res = evmap_io_add(base, ev->ev_fd, ev); //加入io队列
    
    else if (ev->ev_events & EV_SIGNAL)
    
    res = evmap_signal_add(base, (int)ev->ev_fd, ev);//加入信号队列
    
    if (res != -1)
    
    event_queue_insert(base, ev, EVLIST_INSERTED);//向event_base注册事件
    
    }
    
    ...
    
    return (res);
    
    }

event\_add函数只是对event\_base加了锁，然后调用event\_add\_internal函数完成工作。所以函数event\_add是线程安全的。

event\_add\_internal函数会调用前几篇博文讲到的evmap\_io\_add和evmap\_signal\_add，把有相同文件描述符fd和信号值sig的event连在一个队列里面。成功之后，就会调用event\_queue\_insert，向event\_base注册事件。

前面博文的evmap\_io\_add和evmap\_signal\_add函数内部还有一些地方并没有说到。那就是把要监听的fd或者sig添加到多路IO复用函数中，使得其是可以监听的。

//evmap.c文件
    
    int
    
    evmap_io_add(struct event_base *base, evutil_socket_t fd, struct event *ev)
    
    {
    
    const struct eventop *evsel = base->evsel;
    
    struct event_io_map *io = &base->io;
    
    struct evmap_io *ctx = NULL;
    
    int nread, nwrite, retval = 0;
    
    short res = 0, old = 0;
    
    struct event *old_ev;
    
    
    ...
    
    
    //GET_IO_SLOT_AND_CTOR宏的作用就是让ctx指向struct event_map_entry结构体中的TAILQ_HEAD
    
    //宏的展开，可以到http://blog.csdn.net/luotuo44/article/details/38403241查看
    
    GET_IO_SLOT_AND_CTOR(ctx, io, fd, evmap_io, evmap_io_init,
    
    evsel->fdinfo_len);
    
    
    //同一个fd可以调用event_new,event_add
    
    //多次。nread、nwrite就是记录有多少次。如果每次event_new的回调函数
    
    //都不一样，那么当fd有可读或者可写时，这些回调函数都是会触发的。
    
    //对一个fd不能event_new、event_add太多次的。后面会进行判断
    
    nread = ctx->nread;
    
    nwrite = ctx->nwrite;
    
    
    if (nread)
    
    old |= EV_READ;
    
    if (nwrite)
    
    old |= EV_WRITE;
    
    
    if (ev->ev_events & EV_READ) {
    
    //记录是不是第一次。如果是第一次，那么就说明该fd还没被
    
    //加入到多路IO复用中。即还没被加入到像select、epoll这些
    
    //函数中。那么就要加入。这个在后面可以看到。
    
    if (++nread == 1)
    
    res |= EV_READ;
    
    }
    
    if (ev->ev_events & EV_WRITE) {
    
    if (++nwrite == 1)
    
    res |= EV_WRITE;
    
    }
    
    if (EVUTIL_UNLIKELY(nread > 0xffff || nwrite > 0xffff)) {
    
    event_warnx("Too many events reading or writing on fd %d",
    
    (int)fd);
    
    return -1;
    
    }
    
    
    
    //把fd加入到多路IO复用中。
    
    if (res) {
    
    void *extra = ((char*)ctx) + sizeof(struct evmap_io);
    
    if (evsel->add(base, ev->ev_fd,
    
    old, (ev->ev_events & EV_ET) | res, extra) == -1)
    
    return (-1);
    
    retval = 1;
    
    }
    
    
    //nread进行了++。把次数记录下来。下次对于同一个fd，这个次数就有用了
    
    ctx->nread = (ev_uint16_t) nread;
    
    ctx->nwrite = (ev_uint16_t) nwrite;
    
    
    TAILQ_INSERT_TAIL(&ctx->events, ev, ev_io_next);
    
    
    return (retval);
    
    }

代码中有两个计数nread和nwrite，当其值为1时，就说明是第一次监听对应的事件。此时，就要把这个fd添加到多路IO复用函数中。这就完成fd与select、poll、epoll之类的多路IO复用函数的相关联。这完成对fd监听的第一步。

下面再看event\_queue\_insert函数的实现。

//event.c文件
    
    static void
    
    event_queue_insert(struct event_base *base, struct event *ev, int queue)
    
    {
    
    ...
    
    
    ev->ev_flags |= queue;
    
    switch (queue) {
    
    case EVLIST_INSERTED:
    
    TAILQ_INSERT_TAIL(&base->eventqueue, ev, ev_next);
    
    break;
    
    ...
    
    }
    
    }

这个函数的主要作为是把event加入到对应的队列中。在这里，是为了把event加入到eventqueue这个已注册队列中，即将event向event\_base注册。注意，此时event结构体的ev\_flags变量为EVLIST\_INIT | EVLIST\_INSERTED了。

# 进入主循环，开始监听event： #

现在事件已经添加完毕，开始进入主循环event\_base\_dispatch函数。还是同样，该函数内部调用event\_base\_loop完成工作。

//event.c文件
    
    int
    
    event_base_loop(struct event_base *base, int flags)
    
    {
    
    const struct eventop *evsel = base->evsel;
    
    int res, done, retval = 0;
    
    
    //加锁
    
    EVBASE_ACQUIRE_LOCK(base, th_base_lock);
    
    
    done = 0;
    
    
    while (!done) {
    
    //该函数的内部会解锁，然后调用OS提供的的多路IO复用函数。
    
    //这个函数退出后，又会立即加锁。这有点像条件变量。
    
    res = evsel->dispatch(base, tv_p);
    
    
    if (N_ACTIVE_CALLBACKS(base)) {
    
    int n = event_process_active(base);
    
    }
    
    }
    
    
    done:
    
    //解锁
    
    EVBASE_RELEASE_LOCK(base, th_base_lock);
    
    return (retval);
    
    }

在event\_base\_loop函数内部会进行加锁，这是因为这里要对event\_base里面的多个队列进行一些数据操作(增删操作)，此时要用锁来保护队列不被另外一个线程所破坏。

上面代码中有两个函数evsel->dispatch和event\_process\_active。前一个将调用多路IO复用函数，对event进行监听，并且把满足条件的event放到event\_base的激活队列中。后一个则遍历这个激活队列的所有event，逐个调用对应的回调函数。

可以看到整个流程如下图所示：

![SouthEast][]

# 将已激活event插入到激活列表： #

我们还是深入看看Libevent是怎么把event添加到激活队列的。dispatch是一个函数指针，它的实现都包含是一个多路IO复用函数。这里选择poll这个多路IO复用函数来作分析。

//poll.c文件
    
    static int
    
    poll_dispatch(struct event_base *base, struct timeval *tv)
    
    {
    
    int res, i, j, nfds;
    
    long msec = -1;
    
    struct pollop *pop = base->evbase;
    
    struct pollfd *event_set;
    
    
    nfds = pop->nfds;
    
    
    event_set = pop->event_set;
    
    
    //解锁
    
    EVBASE_RELEASE_LOCK(base, th_base_lock);
    
    res = poll(event_set, nfds, msec);
    
    //再次加锁
    
    EVBASE_ACQUIRE_LOCK(base, th_base_lock);
    
    
    ...
    
    
    i = random() % nfds;
    
    for (j = 0; j < nfds; j++) {
    
    int what;
    
    if (++i == nfds)
    
    i = 0;
    
    what = event_set[i].revents;
    
    if (!what)
    
    continue;
    
    
    res = 0;
    
    
    //如果fd发生错误，就把之当作读和写事件。之后调用read
    
    //或者write时，就能得知具体是什么错误了。这里的作用是
    
    //通知到上层。
    
    if (what & (POLLHUP|POLLERR))
    
    what |= POLLIN|POLLOUT;
    
    
    if (what & POLLIN)
    
    res |= EV_READ;
    
    if (what & POLLOUT)
    
    res |= EV_WRITE;
    
    if (res == 0)
    
    continue;
    
    
    //把这个ev放到激活队列中。
    
    evmap_io_active(base, event_set[i].fd, res);
    
    }
    
    
    return (0);
    
    }

pollfd数组的数据是在evmap\_io\_add函数中添加的，在evmap\_io\_add函数里面，有一个evsel->add调用，它会把数据(fd和对应的监听类型)放到pollfd数组中。

当主线程从poll返回时，没有错误的话，就说明有些监听的事件发生了。在函数的后面，它会遍历这个pollfd数组，查看哪个fd是有事件发生。如果事件发生，就调用evmap\_io\_active(base, event\_set\[i\].fd, res);在这个函数里面会把这个fd对应的event放到event\_base的激活event队列中。下面是evmap\_io\_active的代码。

void //evmap.c文件
    
    evmap_io_active(struct event_base *base, evutil_socket_t fd, short events)
    
    {
    
    struct event_io_map *io = &base->io;
    
    struct evmap_io *ctx;
    
    struct event *ev;
    
    
    //由这个fd找到对应event_map_entry的TAILQ_HEAD.
    
    GET_IO_SLOT(ctx, io, fd, evmap_io);
    
    
    //遍历这个队列。将所有与fd相关联的event结构体都处理一遍
    
    TAILQ_FOREACH(ev, &ctx->events, ev_io_next) {
    
    if (ev->ev_events & events)
    
    event_active_nolock(ev, ev->ev_events & events, 1);
    
    }
    
    }
    
    
    void //event.c文件
    
    event_active_nolock(struct event *ev, int res, short ncalls)
    
    {
    
    struct event_base *base;
    
    base = ev->ev_base;
    
    
    ...
    
    //将ev插入到激活队列
    
    event_queue_insert(base, ev, EVLIST_ACTIVE);
    
    
    ...
    
    }
    
    
    
    //将event 插入到event_base的对应(由queue指定)的队列里面
    
    static void //event.c文件
    
    event_queue_insert(struct event_base *base, struct event *ev, int queue)
    
    {
    
    ...
    
    
    ev->ev_flags |= queue;
    
    switch (queue) {
    
    case EVLIST_ACTIVE:
    
    base->event_count_active++;
    
    //将event插入到对应对应优先级的激活队列中
    
    TAILQ_INSERT_TAIL(&base->activequeues[ev->ev_pri],
    
    ev,ev_active_next);
    
    break;
    
    }
    
    }

经过上面三个函数的调用，就可以把一个fd对应的所有符合条件的event插入到激活队列中。因为Libevent还对事件处理设有优先级，所以有一个激活数组队列，而不是只有一个激活队列。

注意，此时event结构体的ev\_flags变量为EVLIST\_INIT | EVLIST\_INSERTED | EVLIST\_ACTIVE了。

# 处理激活列表中的event： #

现在已经完成了将event插入到激活队列中。接下来就是遍历激活数组队列，把所有激活的event都处理即可。

现在来追踪event\_process\_active函数。

//event.c文件
    
    static int
    
    event_process_active(struct event_base *base)
    
    {
    
    struct event_list *activeq = NULL;
    
    int i, c = 0;
    
    
    //从高优先级到低优先级遍历优先级数组
    
    for (i = 0; i < base->nactivequeues; ++i) {
    
    //对于特定的优先级，遍历该优先级的所有激活event
    
    if (TAILQ_FIRST(&base->activequeues[i]) != NULL) {
    
    activeq = &base->activequeues[i];
    
    c = event_process_active_single_queue(base, activeq);
    
    ...
    
    }
    
    }
    
    return c;
    
    }
    
    
    static int
    
    event_process_active_single_queue(struct event_base *base,
    
    struct event_list *activeq)
    
    {
    
    struct event *ev;
    
    int count = 0;
    
    
    for (ev = TAILQ_FIRST(activeq); ev; ev = TAILQ_FIRST(activeq)) {
    
    //如果是永久事件，那么只需从active队列中删除。
    
    if (ev->ev_events & EV_PERSIST)
    
    event_queue_remove(base, ev, EVLIST_ACTIVE);
    
    else //不是的话，那么就要把这个event删除掉。
    
    event_del_internal(ev);
    
    if (!(ev->ev_flags & EVLIST_INTERNAL))
    
    ++count;
    
    
    //下面开始处理这个event
    
    switch (ev->ev_closure) {
    
    ...
    
    case EV_CLOSURE_NONE:
    
    //调用用户设置的回调函数。
    
    (*ev->ev_callback)(ev->ev_fd, ev->ev_res, ev->ev_arg);
    
    break;
    
    }
    
    
    EVBASE_ACQUIRE_LOCK(base, th_base_lock);
    
    
    }
    
    return count;
    
    }

上面的代码，从高到低优先级遍历激活event优先级数组。对于激活的event，要调用event\_queue\_remove将之从激活队列中删除掉。然后再对这个event调用其回调函数。

event\_queue\_remove函数的调用会改变event结构体的ev\_flags变量的值。调用后， ev\_flags变量为EVLIST\_INIT | EVLIST\_INSERTED。现在又可以等待下一次事件的到来了。 -

[Link 1]: http://blog.csdn.net/luotuo44/article/details/38350633
[Link 2]: http://blog.csdn.net/luotuo44/article/details/38360525
[event_base]: http://blog.csdn.net/luotuo44/article/details/38443569
[Reactor]: http://blog.csdn.net/luotuo44/article/details/38458469
[event]: http://blog.csdn.net/luotuo44/article/details/38538991
[SouthEast]: /images/20220509/eb252635de0e4a1585f29199a007e824.png