目录
信号event处理流程
与信号event相关的结构体
初始化工作
创建一个信号event
添加一个信号event
信号回调函数
信号event的激活
Libevent中的event，主要分为三大类：io读写event、超时事件以及信号event。前面的文章对前两类的event都进行了分析，下面就来说一下Libevent是如何处理信号event的。
信号event处理流程
不管使用的是什么后端IO复用模型，这些复用模型本身都是只支持读写IO事件的，Libevent所实现的“信号event处理”，实际上也是把信号event最终转换到了IO读写event。它的工作原理为：用户层面指定一个需要监听的信号sig以及回调函数custom_cb，对于Libevent，它会为sig定义一个信号处理函数evsig_handler，然后再定义一个socket pair，这是一对全双工套接字，向其中一个写入数据那么就可以从另一个中读出数据，Libevent会将其中之一固定为读端，而另一个则为写端，并为读端套接字注册一个IOevent名为ev_signal，其回调函数为evsig_cb。
当需要监听的信号sig到达，就会自动去调用刚才设置的信号处理函数evsig_handler，在evsig_handler中会向写端套接字写入一个字节（这个字节实际上就是sig的值），此时读端套接字就会收到这个字节，触发可读事件，激活ev_signal然后调用evsig_cb，在evsig_cb函数中，会将所有监听sig信号的event全部激活，这些event中就包含根据用户要求所定义的event，处理这个event的时候就会回调custom_cb，这样，就完成了监听sig信号到回调custom_cb的信号event处理过程。如下图所示：
与信号event相关的结构体
struct event_base {
......
const struct eventop *evsigsel;//信号处理后端相关函数
/** Data to implement the common signal handelr code. */
struct evsig_info sig;//信号相关信息
......
/** Mapping from file descriptors to enabled (added) events */
struct event_io_map io;
/** Mapping from signal numbers to enabled (added) events. */
struct event_signal_map sigmap;
......
};
前面说过，event_base在初始化的时候就会绑定一个IO复用模型后端到evsel成员中，但是对于信号event，整个处理的过程中是不会也不应该直接使用这些IO复用后端，而是使用信号event专用的后端，并且将其绑定到evsigsel中，在该后端结构体中只含有添加和删除函数，如下所示：
static const struct eventop evsigops = {
"signal",
NULL,
evsig_add,
evsig_del,
NULL,
NULL,
0, 0, 0
};
然后再说event_base中的sig成员，这是一个evsig_info类型的结构体变量，该类型定义如下：
typedef void (*ev_sighandler_t)(int);
struct evsig_info {
struct event ev_signal; //需要添加到event_io_map中监听读端套接字
/* Socketpair used to send notifications from the signal handler */
evutil_socket_t ev_signal_pair[2];//一对全双工套接字
/* True iff we've added the ev_signal event yet. */
int ev_signal_added; //标识ev_signal是否被添加到io map中
/* Count of the number of signals we're currently watching. */
int ev_n_signals_added; //监听的信号数量
#ifdef _EVENT_HAVE_SIGACTION
struct sigaction **sh_old; //sigaction *数组，每一个元素都指向一个sigaction，其中含有信号的处理函数
#else
ev_sighandler_t **sh_old; //如果没有定义_EVENT_HAVE_SIGACTION，那么就是一个函数指针数组，存储每个信号的回调函数指针
#endif
/* Size of sh_old. */
int sh_old_max; //sh_old数组的大小
};
这里的ev_signal_pair[2]就是前面所说的socket pair全双工套接字。而evsig_info中的ev_signal，就是用于监听socket pair中读端套接字的event。sh_old是一个二级指针，也可以看做数组，它每个元素都对应了一个信号的处理函数。
初始化工作
对于普通的IO复用模型，是在event_base的初始化过程中将相应的后端结构体绑定到evsel中的，同样的，信号相关的后端结构体也是在event_base的初始化过程中绑定到evsigsel中的，并且还会做很多事情，如下所示：
struct event_base *
event_base_new_with_config(const struct event_config *cfg)
{
......
for (i = 0; eventops[i] && !base->evbase; i++) {
......
base->evsel = eventops[i]; //将该backup作为base使用的backup
base->evbase = base->evsel->init(base); //用选定的backup的初始化函数来初始化base中的evbase
}
......
}
//以epoll后端为例
static void *
epoll_init(struct event_base *base)
{
......
evsig_init(base);
}
int
evsig_init(struct event_base *base)
{
if (evutil_socketpair(
AF_UNIX, SOCK_STREAM, 0, base->sig.ev_signal_pair) == -1) {//创建了两个互相连接的套接字放到ev_signal_pair中
......
}
evutil_make_socket_closeonexec(base->sig.ev_signal_pair[0]);//调用exec时关闭套接字
evutil_make_socket_closeonexec(base->sig.ev_signal_pair[1]);
base->sig.sh_old = NULL;
base->sig.sh_old_max = 0;
evutil_make_socket_nonblocking(base->sig.ev_signal_pair[0]);//将创建的两个套接字都设置为非阻塞
evutil_make_socket_nonblocking(base->sig.ev_signal_pair[1]);
......
}
在evsig_init函数中，会先调用evutil_socketpair来创建一对全双工套接字，该函数定义如下：
int
evutil_socketpair(int family, int type, int protocol, evutil_socket_t fd[2])//创建一对相互连接的套接字，保存在fd[2]中
{
#ifndef WIN32
return socketpair(family, type, protocol, fd);
#else
return evutil_ersatz_socketpair(family, type, protocol, fd);
#endif
}
int
evutil_ersatz_socketpair(int family, int type, int protocol,
evutil_socket_t fd[2])
{
/* This code is originally from Tor. Used with permission. */
/* This socketpair does not work when localhost is down. So
* it's really not the same thing at all. But it's close enough
* for now, and really, when localhost is down sometimes, we
* have other problems too.
*/
#ifdef WIN32
#define ERR(e) WSA##e
#else
#define ERR(e) e
#endif
evutil_socket_t listener = -1;
evutil_socket_t connector = -1;
evutil_socket_t acceptor = -1;
struct sockaddr_in listen_addr;
struct sockaddr_in connect_addr;
ev_socklen_t size;
int saved_errno = -1;
if (protocol
|| (family != AF_INET
#ifdef AF_UNIX
&& family != AF_UNIX
#endif
)) {
EVUTIL_SET_SOCKET_ERROR(ERR(EAFNOSUPPORT));
return -1;
}
if (!fd) {
EVUTIL_SET_SOCKET_ERROR(ERR(EINVAL));
return -1;
}
listener = socket(AF_INET, type, 0);
if (listener < 0)
return -1;
memset(&listen_addr, 0, sizeof(listen_addr));
listen_addr.sin_family = AF_INET;
listen_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);//listen监听本地环回地址
listen_addr.sin_port = 0; /* kernel chooses port. */
if (bind(listener, (struct sockaddr *) &listen_addr, sizeof (listen_addr))
== -1)
goto tidy_up_and_fail;
if (listen(listener, 1) == -1)//开始监听
goto tidy_up_and_fail;
connector = socket(AF_INET, type, 0); //创建connector套接字
if (connector < 0)
goto tidy_up_and_fail;
/* We want to find out the port number to connect to. */
size = sizeof(connect_addr);
if (getsockname(listener, (struct sockaddr *) &connect_addr, &size) == -1)//获取listener绑定的ip地址，保存到connect_addr中
goto tidy_up_and_fail;
if (size != sizeof (connect_addr))
goto abort_tidy_up_and_fail;
if (connect(connector, (struct sockaddr *) &connect_addr,
sizeof(connect_addr)) == -1)//将connector与listener连接
goto tidy_up_and_fail;
size = sizeof(listen_addr);
acceptor = accept(listener, (struct sockaddr *) &listen_addr, &size);//通过acceptor可以向connector发送数据
if (acceptor < 0)
goto tidy_up_and_fail;
if (size != sizeof(listen_addr))
goto abort_tidy_up_and_fail;
evutil_closesocket(listener);
/* Now check we are talking to ourself by matching port and host on the
two sockets. */
if (getsockname(connector, (struct sockaddr *) &connect_addr, &size) == -1)//确保是本地环回监听
goto tidy_up_and_fail;
if (size != sizeof (connect_addr)
|| listen_addr.sin_family != connect_addr.sin_family
|| listen_addr.sin_addr.s_addr != connect_addr.sin_addr.s_addr
|| listen_addr.sin_port != connect_addr.sin_port)
goto abort_tidy_up_and_fail;
fd[0] = connector;//通过connector向listener发信息
fd[1] = acceptor; //通过acceptor向connector发信息
return 0;
......
}
创建一对全双工套接字的流程是：先创建一个listener，监听本地环回端口，相当于服务端。创建一个connector作为客户端向listener发起连接，listener通过accept函数与connecotr建立连接，新连接套接字为acceptor，此时acceptor和connector就可以互发消息，成为一对全双工套接字。
再回到evsig_init函数中，接着就会把创建的这对套接字设置为非阻塞，并且在执行exec时关闭。接下来会调用event_assign函数，设置ev_signal的监听对象就是这对套接字之一，并且监听读事件，回调函数为evsig_cb，这点就对应了前面处理流程中紫色框部分。然后就是将信号处理后端函数结构体绑定到event_base中的evsigsel上。
int
evsig_init(struct event_base *base)
{
......
event_assign(&base->sig.ev_signal, base, base->sig.ev_signal_pair[1],
EV_READ | EV_PERSIST, evsig_cb, base);//pair[1]为读端，为其注册ev_signal，类型为永久性读事件
base->sig.ev_signal.ev_flags |= EVLIST_INTERNAL;//标识为内部事件
event_priority_set(&base->sig.ev_signal, 0);//signal event优先级为0
base->evsigsel = &evsigops;//绑定信号处理后端函数调用结构体
return 0;
}
到这里，初始化就算是完成了，关于ev_signal的回调函数后面再说，接下来就进入信号event的处理过程。
创建一个信号event
创建一个io event的函数是event_new，如果要创建信号event，一种方法是直接设置event_new的参数为EV_SIGNAL，不过这种方法对于用户来说是非常不友好的。为此，Libevent在event.h中进行了如下的宏定义：
#define evsignal_add(ev, tv) event_add((ev), (tv))
#define evsignal_assign(ev, b, x, cb, arg)
event_assign((ev), (b), (x), EV_SIGNAL|EV_PERSIST, cb, (arg))
#define evsignal_new(b, x, cb, arg)
event_new((b), (x), EV_SIGNAL|EV_PERSIST, (cb), (arg))
#define evsignal_del(ev) event_del(ev)
#define evsignal_pending(ev, tv) event_pending((ev), EV_SIGNAL, (tv))
#define evsignal_initialized(ev) event_initialized(ev)
可以看到，这里实际上对io event的相关函数的参数进行了“特殊化处理”，最终得到了信号event的相关函数。此时，就可以通过evsignal_new函数来创建一个信号event了，实际上就是创建了一个EV_SIGNAL|EV_PERSIST的永久信号事件。而该函数内部实际上又会调用event_assign函数。需要注意的是，创建普通event时第二个参数传入的是需要监听的的文件描述符，而这里创建信号event时传入的第二个参数则应当是需要监听的信号值了，比如说需要监听的信号是SIGUSR1，那么调用evsignal_new时，传入的第二个参数就应该直接使用SIGUSR1。evsignal_new的第三个参数cb自然就应当是用户需要监听的信号发生后，期待调用的函数。
接下来再来分析如何添加一个信号event。
添加一个信号event
如上所述，添加一个信号event使用evsignal_add函数，实际上就是event_add函数。前面创建的信号event，其events成员已经被设置为了EV_SIGNAL|EV_PERSIST。因此，event_add函数中会调用evmap_signal_add函数将该event添加到event_signal_map中，evmap_signal_add如下所示：
int
evmap_signal_add(struct event_base *base, int sig, struct event *ev)
{
const struct eventop *evsel = base->evsigsel;//使用的是信号回调函数结构体
struct event_signal_map *map = &base->sigmap;
struct evmap_signal *ctx = NULL;
if (sig >= map->nentries) {
if (evmap_make_space(
map, sig, sizeof(struct evmap_signal *)) == -1)
return (-1);
}
GET_SIGNAL_SLOT_AND_CTOR(ctx, map, sig, evmap_signal, evmap_signal_init,
base->evsigsel->fdinfo_len); //ctx指向sigmap的entries[sig]对应的evmap_signal，evmap_signal中含有一个event双向链表
if (TAILQ_EMPTY(&ctx->events)) {
if (evsel->add(base, ev->ev_fd, 0, EV_SIGNAL, NULL)//调用的实际上是evsigsel中的add函数
== -1)
return (-1);
}
TAILQ_INSERT_TAIL(&ctx->events, ev, ev_signal_next);
return (1);
}
可以看到，在通过TAILQ_INSERT_TAIL将前面创建的event添加到event_signal_map之前，会先调用信号回调后端函数中的add函数，也就是前面的evsig_add函数，该函数定义如下：
static int
evsig_add(struct event_base *base, evutil_socket_t evsignal, short old, short events, void *p)
{
struct evsig_info *sig = &base->sig;
(void)p;
EVUTIL_ASSERT(evsignal >= 0 && evsignal < NSIG);
/* catch signals if they happen quickly */
EVSIGBASE_LOCK();
if (evsig_base != base && evsig_base_n_signals_added) {
event_warnx("Added a signal to event base %p with signals "
"already added to event_base %p. Only one can have "
"signals at a time with the %s backend. The base with "
"the most recently added signal or the most recent "
"event_base_loop() call gets preference; do "
"not rely on this behavior in future Libevent versions.",
base, evsig_base, base->evsel->name);
}
evsig_base = base;
evsig_base_n_signals_added = ++sig->ev_n_signals_added;
evsig_base_fd = base->sig.ev_signal_pair[0];//pair[0]是写端
EVSIGBASE_UNLOCK();
event_debug(("%s: %d: changing signal handler", __func__, (int)evsignal));
if (_evsig_set_handler(base, (int)evsignal, evsig_handler) == -1) {//设置信号处理函数
goto err;
}
if (!sig->ev_signal_added) {//如果还没有添加ev_signal，就调用event_add添加，如果添加过了就不用再添加了
if (event_add(&sig->ev_signal, NULL))//ev_signal的事件类型为READ|PERSIST
goto err;
sig->ev_signal_added = 1;
}
return (0);
err:
EVSIGBASE_LOCK();
--evsig_base_n_signals_added;
--sig->ev_n_signals_added;
EVSIGBASE_UNLOCK();
return (-1);
}
evsig_add函数做了两件重要的事情：设置信号回调函数，将监听读端套接字事件的ev_signal进行添加。
信号回调函数的设置是通过_evsig_set_handler函数实现的，实际上它内部还是用的signal或者sigaction函数，并且将设置的信号回调函数都放到了sig的sh_old数组中，数组的索引就是信号值。该函数定义如下：
int
_evsig_set_handler(struct event_base *base,
int evsignal, void (__cdecl *handler)(int))
{
#ifdef _EVENT_HAVE_SIGACTION
struct sigaction sa; //存储新的信号处理信息
#else
ev_sighandler_t sh; //信号处理函数指针
#endif
struct evsig_info *sig = &base->sig;
void *p;
/*
* resize saved signal handler array up to the highest signal number.
* a dynamic array is used to keep footprint on the low side.
*/
if (evsignal >= sig->sh_old_max) {//数组大小不够，就进行扩容
int new_max = evsignal + 1;
event_debug(("%s: evsignal (%d) >= sh_old_max (%d), resizing",
__func__, evsignal, sig->sh_old_max));
p = mm_realloc(sig->sh_old, new_max * sizeof(*sig->sh_old));
if (p == NULL) {
event_warn("realloc");
return (-1);
}
memset((char *)p + sig->sh_old_max * sizeof(*sig->sh_old),
0, (new_max - sig->sh_old_max) * sizeof(*sig->sh_old));
sig->sh_old_max = new_max;
sig->sh_old = p;
}
/* allocate space for previous handler out of dynamic array */
sig->sh_old[evsignal] = mm_malloc(sizeof *sig->sh_old[evsignal]);
if (sig->sh_old[evsignal] == NULL) {
event_warn("malloc");
return (-1);
}
//添加信号处理函数
/* save previous handler and setup new handler */
#ifdef _EVENT_HAVE_SIGACTION
memset(&sa, 0, sizeof(sa));
sa.sa_handler = handler;//信号处理函数
sa.sa_flags |= SA_RESTART;//被信号中断的系统调用会自动重启
sigfillset(&sa.sa_mask);//阻塞所有信号
if (sigaction(evsignal, &sa, sig->sh_old[evsignal]) == -1) {//sig->sh_old[evsignal]中保存evsignal原本的信号处理函数
event_warn("sigaction");
mm_free(sig->sh_old[evsignal]);
sig->sh_old[evsignal] = NULL;
return (-1);
}
#else
if ((sh = signal(evsignal, handler)) == SIG_ERR) {
event_warn("signal");
mm_free(sig->sh_old[evsignal]);
sig->sh_old[evsignal] = NULL;
return (-1);
}
*sig->sh_old[evsignal] = sh; //存储信号处理函数
#endif
return (0);
}
通过_evsig_set_handler函数，就把信号sig的回调函数设置为evsig_handler，也就是调用_evsig_set_handler的第三个参数。当信号sig达到时，就会自动调用evsig_handler函数。
evsig_handler函数后面再说，先回到evsig_add函数中。设置好信号回调函数之后，就会将ev_signal通过event_add函数进行添加，前面说过，ev_signal的监听事件类型为EV_READ|EV_PERSIST，它用来监听socket pair中的读端套接字是否有可读事件发生。
也就是说，通过evsig_add函数，不仅设置了信号回调函数，还设置监听读端套接字是否有可读事件发生。
接下来再来看看信号回调函数到底做了什么事。
信号回调函数
evsig_handler函数定义如下所示：
static void __cdecl
evsig_handler(int sig)//信号处理函数，当信号发生时调用该函数
{
int save_errno = errno;
#ifdef WIN32
int socket_errno = EVUTIL_SOCKET_ERROR();
#endif
ev_uint8_t msg;
if (evsig_base == NULL) {
event_warnx(
"%s: received signal %d, but have no base configured",
__func__, sig);
return;
}
#ifndef _EVENT_HAVE_SIGACTION
signal(sig, evsig_handler);
#endif
/* Wake up our notification mechanism */
msg = sig;
send(evsig_base_fd, (char*)&msg, 1, 0);//向写端pair[0]写入信号值，那么读端pair[1]就会收到该信号值
errno = save_errno;
#ifdef WIN32
EVUTIL_SET_SOCKET_ERROR(socket_errno);
#endif
}
这个函数的功能很简单，就是向socket pair中的写端写入一个字节的数据，而这一字节就是信号的值。当这个字节通过socket pair的写端套接字写入之后，socket pair的读端就会读到该字节，读端套接字可读事件发生，监听该事件的ev_signal就会被激活。激活后调用ev_signal的回调函数evsig_cb，该函数定义如下：
static void
evsig_cb(evutil_socket_t fd, short what, void *arg)
{
static char signals[1024];
ev_ssize_t n;
int i;
int ncaught[NSIG];
struct event_base *base;
base = arg;
memset(&ncaught, 0, sizeof(ncaught));
while (1) {
n = recv(fd, signals, sizeof(signals), 0);//从读端pair[1]读取数据，fd是非阻塞的，如果
if (n == -1) {//说明没有数据可读，或者出错了
int err = evutil_socket_geterror(fd);
if (! EVUTIL_ERR_RW_RETRIABLE(err))
event_sock_err(1, fd, "%s: recv", __func__);
break;
} else if (n == 0) {//说明对端关闭
/* XXX warn? */
break;
}
for (i = 0; i < n; ++i) {//读到了多少个字节，说明收到了多少个信号
ev_uint8_t sig = signals[i];
if (sig < NSIG)
ncaught[sig]++;//记录该信号被捕获的次数，捕获多少次就应该激活多少次
}
}
EVBASE_ACQUIRE_LOCK(base, th_base_lock);
for (i = 0; i < NSIG; ++i) {//遍历所有被捕获的信号，将其对应的event激活
if (ncaught[i])
evmap_signal_active(base, i, ncaught[i]);
}
EVBASE_RELEASE_LOCK(base, th_base_lock);
}
evsig_cb会从读端套接字中读取数据到signals数组中，读出的每一个字节都代表一个发生的信号值，用ncaught数组来存储每个信号发生的次数，并且对于每个发生的信号，都调用evmap_signal_active进行处理，可以参考event_signal_map的激活。
信号event的激活
evmap_signal_active主要是找到event_signal_map中，监听信号值为sig的那一个evmap_signal，在这个evmap_signal中，包含了所有监听信号值为sig的event组成的双向链表，然后直接遍历这个双向链表，把每个元素都按照EV_SIGNAL的激活方式调用event_active_nolock函数。
void
evmap_signal_active(struct event_base *base, evutil_socket_t sig, int ncalls)
{
struct event_signal_map *map = &base->sigmap;
struct evmap_signal *ctx;
struct event *ev;
EVUTIL_ASSERT(sig < map->nentries);
GET_SIGNAL_SLOT(ctx, map, sig, evmap_signal); //ctx保存信号值为sig的evmap_signal，也就是一个event的双向链表
TAILQ_FOREACH(ev, &ctx->events, ev_signal_next)
event_active_nolock(ev, EV_SIGNAL, ncalls);//遍历信号值为Sig的event双向链表，将每个event以EV_SIGNAL方式激活
}
而对于event_active_nolock函数来说，做的事情很少，就是把传入的event添加到激活队列中，如下所示：
void
event_active_nolock(struct event *ev, int res, short ncalls)
{
......
event_queue_insert(base, ev, EVLIST_ACTIVE); //将event插入到激活队列中
......
}
到这里，用来监听用户指定的信号值的那个信号event就被添加到了激活队列中，接下来，就等待主循环处理激活队列时去处理那个信号event。
int
event_base_loop(struct event_base *base, int flags)
{
......
if (N_ACTIVE_CALLBACKS(base)) { //如果激活队列中有事件
int n = event_process_active(base); //执行激活队列中的event相应的回调函数，返回的n是成功执行的非内部事件数目
......
}
static int
event_process_active(struct event_base *base)//遍历base的激活队列中所有event，调用其回调函数
{
......
for (i = 0; i < base->nactivequeues; ++i) { //遍历激活队列中的事件
if (TAILQ_FIRST(&base->activequeues[i]) != NULL) { //同一个优先级下可以有多个事件
base->event_running_priority = i; //设置当前的优先级
activeq = &base->activequeues[i]; //获取优先级i下的所有event组成的链表
c = event_process_active_single_queue(base, activeq); //遍历activeq链表，调用其中每个event的回调函数
......
}
}
}
static int
event_process_active_single_queue(struct event_base *base,
struct event_list *activeq)
{
......
switch (ev->ev_closure) { //在调用回调函数是否进行其他行为
case EV_CLOSURE_SIGNAL: //信号事件回调处理方式
event_signal_closure(base, ev);
break;
case EV_CLOSURE_PERSIST: //对于永久事件，在调用回调函数之前会重新调用event_add来添加该事件到对应队列中
event_persist_closure(base, ev);
break;
default:
case EV_CLOSURE_NONE: //对于一般事件，直接调用回调函数
EVBASE_RELEASE_LOCK(base, th_base_lock);//释放锁
(*ev->ev_callback)(
ev->ev_fd, ev->ev_res, ev->ev_arg); //调用回调函数
break;
}
......
}
激活处理的过程就是event_base_loop——event_process_active——event_process_active_single_queue，在event_process_active_single_queue函数中，会判断激活处理事件的回调关闭方式ev_closure，而对于信号event来说，在evsignal_new时由于传入的参数为EV_SIGNAL|EV_PERSIST，因此evsignal_new内部调用的event_assign会直接设置信号event的ev_closure为EV_CLOSURE_SIGNAL，也就是说，处理激活的信号event最终是通过event_signal_closure函数实现的，该函数定义如下：
static inline void
event_signal_closure(struct event_base *base, struct event *ev)
{
......
while (ncalls) {//信号发生了多少次就调用多少次回调函数
ncalls--;
ev->ev_ncalls = ncalls;
if (ncalls == 0)
ev->ev_pncalls = NULL;
(*ev->ev_callback)(ev->ev_fd, ev->ev_res, ev->ev_arg);
......
}
}
这里的ncalls，实际上就是evsig_cb函数中记录的信号值sig的发生次数，信号event激活时只处理一次，但是在这一次中会根据信号发生的次数来决定调用多少次回调函数，而这里的回调函数就是用户最开始设定的“当信号发生时应当调用的函数了”。
————————————————
版权声明：本文为CSDN博主「HerofH_」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_28114615/article/details/97657766