Nginx源代码分析之群惊问题（十七）

我不是女神ヾ 2022-07-17 16:26 180阅读 0赞

接上一节,由于nginx的I/O模型框架是从listen开始处理异步通知，因此存在当同一个connect到达os的内核并完成三次握手，会同时唤醒多个work process来处理这个异步通知。

实际上，根据相关资料，Linux内核本身已经解决了群惊的问题，当多个线程在阻塞模式同时调用一个socket的accept并阻塞，当有请求到来的时候，只有一个进程的accept调用成功并返回，其他进程继续阻塞在accept上面并保持睡眠状态。

但由于nginx使用的是异步I/O的统一框架，并提供多个I/O模型，像select,epoll,queue这样的unix平台下的模型在异步通知这方面仍然存在群惊的情况，因此nginx必须处理这些情况，另外需要注意的是，win平台的overlap,iocp并不存在群惊的情况，因为这2个模型可以投递异步accept，每个connect仅会唤醒一个异步accept。但为了统一网络框架，也只好按unix的方式统一处理。

这里有个全局变量ngx\_use\_accept\_mutex用于控制是否开启“防群惊”模式，同时有一个

在ngx\_event\_process\_init中，会首先判断是否开启 防群惊模式，如果未开启，则直接注册ngx\_event\_accept。代码如下

\#if (NGX\_WIN32)  
if (ngx\_event\_flags & NGX\_USE\_IOCP\_EVENT) \{  
ngx\_iocp\_conf\_t \*iocpcf;  
rev->handler = ngx\_event\_acceptex;  
if (ngx\_use\_accept\_mutex) \{  
continue;  
\}  
if (ngx\_add\_event(rev, 0, NGX\_IOCP\_ACCEPT) == NGX\_ERROR) \{  
return NGX\_ERROR;  
\}  
  
ls\[i\].log.handler = ngx\_acceptex\_log\_error;  
  
iocpcf = ngx\_event\_get\_conf(cycle->conf\_ctx, ngx\_iocp\_module);  
if (ngx\_event\_post\_acceptex(&ls\[i\], iocpcf->post\_acceptex)  
== NGX\_ERROR)  
\{  
return NGX\_ERROR;  
\}  
  
\} else \{  
rev->handler = ngx\_event\_accept;  
if (ngx\_use\_accept\_mutex) \{  
continue;  
\}  
if (ngx\_add\_event(rev, NGX\_READ\_EVENT, 0) == NGX\_ERROR) \{  
return NGX\_ERROR;  
\}  
\}  
\#else  
rev->handler = ngx\_event\_accept;  
if (ngx\_use\_accept\_mutex  
\#if (NGX\_HAVE\_REUSEPORT)  
&& !ls\[i\].reuseport  
\#endif  
)  
\{  
continue;  
\}  
if (ngx\_add\_event(rev, NGX\_READ\_EVENT, 0) == NGX\_ERROR) \{  
return NGX\_ERROR;  
\}  
\#endif

如果开启，这里不会直接注册accept的回调：ngx\_event\_accept,而是在work process的进程函数的ngx\_process\_events\_and\_timers里面有一个获取互斥锁的操作，关键点是获取互斥锁的函数ngx\_trylock\_accept\_mutex，代码如下

ngx\_int\_t  
ngx\_trylock\_accept\_mutex(ngx\_cycle\_t \*cycle)  
\{  
if (ngx\_shmtx\_trylock(&ngx\_accept\_mutex)) \{  
  
  
ngx\_log\_debug0(NGX\_LOG\_DEBUG\_EVENT, cycle->log, 0,  
"accept mutex locked");  
  
  
if (ngx\_accept\_mutex\_held && ngx\_accept\_events == 0) \{  
return NGX\_OK;  
\}  
  
  
if (ngx\_enable\_accept\_events(cycle) == NGX\_ERROR) \{  
ngx\_shmtx\_unlock(&ngx\_accept\_mutex);  
return NGX\_ERROR;  
\}  
  
  
ngx\_accept\_events = 0;  
ngx\_accept\_mutex\_held = 1;  
  
  
return NGX\_OK;  
\}  
  
  
ngx\_log\_debug1(NGX\_LOG\_DEBUG\_EVENT, cycle->log, 0,  
"accept mutex lock failed: %ui", ngx\_accept\_mutex\_held);  
  
  
if (ngx\_accept\_mutex\_held) \{  
if (ngx\_disable\_accept\_events(cycle, 0) == NGX\_ERROR) \{  
return NGX\_ERROR;  
\}  
  
  
ngx\_accept\_mutex\_held = 0;  
\}  
  
  
return NGX\_OK;  
\}

此函数 首先调用ngx\_shmtx\_trylock获取互斥锁，ngx\_shmtx\_trylock是异步版的，不管是否成功都会立即返回，不会造成进程/线程的阻塞，它的阻塞版是ngx\_shmtx\_lock，后来章节再详细介绍区别。如果成功拿到互斥锁，当前进程就获得了调用accept的权限，接着，判断ngx\_accept\_mutex\_held为1和ngx\_accept\_events 为0，这2个条件都为真说明当前进程之前就是互斥锁的持有者，不需要其他操作直接返回NGX\_OK,否则调用ngx\_enable\_accept\_events，遍历所有处于listen状态的socket，为每个连接设置异步读通知,然后直接返回。

如果获取互斥锁失败，而且ngx\_accept\_mutex\_held的值为1，则调用ngx\_disable\_accept\_events取消当前进程对每个socket的异步通知状态。

ngx\_trylock\_accept\_mutex返回之后，如果调用成功并且持有互斥锁，给flags添加标志NGX\_POST\_EVENTS，随后调用ngx\_process\_events,前面章节已经介绍过这是真正执行异步调用的函数,如果flags包含NGX\_POST\_EVENTS,ngx\_process\_events会获取的所有已经就绪的I/O请求放到等待队列中。代码如下：

if ((revents & EPOLLIN) && rev->active) \{  
  
  
\#if (NGX\_HAVE\_EPOLLRDHUP)  
if (revents & EPOLLRDHUP) \{  
rev->pending\_eof = 1;  
\}  
\#endif  
  
  
rev->ready = 1;  
  
  
if (flags & NGX\_POST\_EVENTS) \{  
queue = rev->accept ? &ngx\_posted\_accept\_events  
: &ngx\_posted\_events;  
  
  
ngx\_post\_event(rev, queue);  
  
  
\} else \{  
rev->handler(rev);  
\}  
\}

其中accept单独放到ngx\_posted\_accept\_events队列，其他读写请求放到ngx\_posted\_events队列。

然后立即处理调用ngx\_event\_process\_posted处理异步accept请求，完成后释放accept的互斥锁。

ngx\_event\_process\_posted(cycle, &ngx\_posted\_accept\_events);  
  
  
if (ngx\_accept\_mutex\_held) \{  
ngx\_shmtx\_unlock(&ngx\_accept\_mutex);  
\}

这样做的原因是当前进程在获取accept锁之后应该尽快调用accept（）并释放锁，以便让其他进程尽快accept互斥锁，避免降低整个服务器接受连接的效率。释放之后再调用ngx\_event\_process\_posted处理缓存在等待队列中的其他读写请求。

最后说说ngx\_accept\_disabled，这个全局变量用来实现work process的简单负载均衡的功能。每次成功调用accept之后会重置这个值

ngx\_accept\_disabled = ngx\_cycle->connection\_n / 8  
\- ngx\_cycle->free\_connection\_n;  
  
  
c = ngx\_get\_connection(s, ev->log);  
  
  
if (c == NULL) \{  
if (ngx\_close\_socket(s) == -1) \{  
ngx\_log\_error(NGX\_LOG\_ALERT, ev->log, ngx\_socket\_errno,  
ngx\_close\_socket\_n " failed");  
\}  
  
  
return;  
\}

ngx\_cycle->free\_connection\_n表示当前进程剩余可用连接，当ngx\_cycle->free\_connection\_n小于1/8最大连接的时候，即ngx\_accept\_disabled>0的时候，说明进程比较繁忙，当前进程会放弃获取accept互斥锁，并将ngx\_accept\_disabled减少1，直到减少到<=0，进程最终会得到获取accept锁的机会，避免繁忙进程陷入一直无法获取accept锁的状态。