Anmerkungen zur Nginx-Quellcode-Studie (21) – Ereignismodul 2 – ereignisgesteuerter Kern ngx_process_events_and_timers

Erinnern wir uns zunächst weiterhin daran, dass es im vorherigen Sub-Thread-Ausführungsvorgang einen unbeteiligten Inhalt ngx_process_events_and_timers gab. Heute werden wir diese Funktion untersuchen.

Dieser Artikel stammt von: http://blog.csdn.net/lengzijian/article/details/7601730

Schauen wir uns einige Screenshots von Abschnitt 19 an:

Heute erklären wir hauptsächlich die ereignisgesteuerte Funktion, den roten Teil im Bild:

[cpp]-Ansicht Klartext?

1. src/event/ngx_event.c  
2.   
3. void   
4. ngx_process_events_and_timers(ngx_cycle_t *cycle)  
5. {  
6.     ngx_uint_t  flags;  
7.     ngx_msec_t timer, delta;  
8.   
9.     if (ngx_timer_resolution) {  
10.         timer = NGX_TIMER_INFINITE;  
11.         flags = 0;  
12.   
13.     } else {  
14.         timer = ngx_event_find_timer();  
15.         flags = NGX_UPDATE_TIME;  
16.     }  
17.       
18.     /* 
19.     ngx_use_accept_mutex变量代表是否使用accept互斥体 
20.     默认是使用，可以通过accept_mutex off;指令关闭； 
21.     akzeptieren 🎜>    */
  
22.     if
 (ngx_use_accept_mutex) {  
24.         /* 
25.         ngx_accept_disabled变量在ngx_event_accept函数中计算。 
26.         如果ngx_accept_disabled大于0，就表示该进程接受的链接过多， 
27.         因此放弃一次争抢Akzeptieren mutex的机会，同时将自己减一. 
28.         然后，继续处理已有连接上的事件。 
29.         nginx就利用这一点实现了继承关于连接的基本负载均衡. 
30.         */
  
31.         if
 (ngx_accept_disabled > 0) {  
32.             ngx_accept_disabled--;  
33.   
34.         } else
 {  
35.             /* 
36.             listen套接字放到epoll中. 
37.             塞在epoll_wait时， 
38.             才不会惊群现象。
39. */
40. 🎜 > (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {                                 ><.>                                                                                🎜>
41.  /*
42. Wenn der Prozess die Sperre erhält, wird ein NGX_POST_EVENTS-Flag hinzugefügt.
Die Funktion dieses Flags besteht darin, alle generierten Ereignisse in eine
44. Warteschlange zu stellen und die Ereignisse nach ihrer Freigabe langsam zu verarbeiten. .
Da die Verarbeitungszeit sehr zeitaufwändig sein kann, wird die Sperre nicht zuerst freigegeben und dann verarbeitet ,
45. Dadurch können andere Prozesse keine Sperren erhalten, sodass die Effizienz von ACCEPT gering ist.
46.                                               _POST_EVENTS;
47.                                                                         
/*
Es gibt keinen erworbenen Prozess und natürlich keine Notwendigkeit für das NGX_POST_EVENTS-Flag.
Aber Sie müssen die Verzögerungszeit einstellen, bevor Sie um die Sperre kämpfen.
50.                                                        X_TIMER_INFINITE
ngx_accept_mutex_delay )
51.                                                                   _mutex_delay;
}
}                                                      >
53. } 
54.  
55.  delta = ngx_current_msec; 
56.  
57. /*Als nächstes startet Epoll das Warteereignis,
Die spezifische Implementierung von ngx_process_events entspricht der Funktion ngx_epoll_process_events in Das Epoll-Modul
60. wird später ausführlich erklärt
* /
63. (void) ngx_process_events(cycle, timer, flags);
64. //Statistiken zum Zeitverbrauch dieses Warteereignisses
65. delta = ngx_current_msec - delta; >
66. ngx_log_debug1(NGX_LOG_DEBUG_EVENT, Cycle->log, 0,        
" Timer-Delta: %M"
67. , Delta);
68. >
ngx_posted_accept_events ist eine Ereignis-
70. Warteschlange, die vorübergehend das Akzeptanzereignis speichert, auf das Epoll vom Listening-Socket wartet.
71. Nachdem das oben erwähnte NGX_POST_EVENTS-Flag verwendet wurde, werden alle Akzeptanzereignisse vorübergehend in dieser Warteschlange
72. */
74. ngx_event_process_posted (cycle, &ngx_posted_accept_events); 🎜> // Nachdem alle Akzeptanzereignisse verarbeitet wurden, wird die Sperre aufgehoben, wenn sie gehalten wird.
75. if (ngx_accept_mutex_held) { ngx_shmtx_unlock(&ngx_accept_mutex_);       🎜>
76. Delta ist der zuvor berechnete Zeitverbrauch. Wenn ein Zeitverbrauch im Millisekundenbereich vorliegt, überprüfen Sie die Timer aller Zeiten Timeout verwendet wird, löschen Sie den abgelaufenen Timer aus dem Time-RBTree und rufen Sie die Handlerfunktion des entsprechenden Ereignisses auf, um
*/
79. if (Delta) {
80. ngx_event_expire_timers( );
81. }
, 
82.                                                                                                         
83. /* Normale Ereignisse verarbeiten (auf der Verbindung erhaltene Ereignisse lesen und schreiben),
85. Da jedes Ereignis seine eigene Handler-Methode hat,
86. */
88.  if (ngx_posted_events) {
89.  if
90. (ngx_threaded) {
ngx _wakeup_worker_thread(cycle);
92. } else {
93. ngx_event_process_posted(cycle, &ngx_posted_events);
} 
94. }
}  
95. Vorher gesagt: Das Accept-Ereignis lauscht tatsächlich auf neue Ereignisse am Socket Die Methode der Akzeptanzzeit wird unten vorgestellt:
96. ngx_event_accept:
[cpp] view Klartext?
98. 1. src/event/ngx_event_accept.c  
    2.   
    3. void   
    4. ngx_event_accept(ngx_event_t *ev)  
    5. {  
    6.     socklen_t          socklen;  
    7.     ngx_err_t          err;  
    8.     ngx_log_t         *log;  
    9.     ngx_socket_t       s;  
    10.     ngx_event_t       *rev, *wev;  
    11.     ngx_listening_t   *ls;  
    12.     ngx_connection_t  *c, *lc;  
    13.     ngx_event_conf_t  *ecf;  
    14.     u_char             sa[NGX_SOCKADDRLEN];  
    15.       
    16.     //省略部分代码  
    17.   
    18.     lc = ev->data;  
    19.     ls = lc->listening;  
    20.     ev->ready = 0;  
    21.   
    22.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,  
    23.                    "accept on %V, ready: %d", &ls->addr_text, ev->available);  
    24.   
    25.     tun {  
    26.         socklen = NGX_SOCKADDRLEN;  
    27.         //accept一个新的连接  
    28.         s = accept(lc-> ;fd, (struct sockaddr *) sa, &socklen);  
    29.         //省略部分代码  
    30.           
    31.         /* 
    32.         accept到一个新的连接后，就重新计算ngx_accept_disabled的值， 
    33.         它主要是用来做负载均衡，之前有提过. 
    34.          
    35.         这里，我们可以看到他的就只方式 
    36.         “总连接数的八分之一-   剩余的连接数“ 
    37.         总连接指每个进程设定的最大连接数，这个数字可以再配置文件中指定.
    38.                                                                                                               ngx_accept_disabled ist größer als Null und die Verbindung ist überlastet
    39. 🎜>
    ngx_accept_disabled = ngx_cycle->connection_n / 8
    41. - ngx_cycle- >free_connection_n;
    >
    42. c = ngx_get_connection(s, ev->log); >
    //Speicherpool für den neuen Link erstellen
    45. >
    c->pool = ngx_create_pool(ls->pool_size, ev->log); 🎜>
    47.                                                                                  🎜>
    48. c->sockaddr = ngx_palloc(c->pool, socklen); >
    49. if (c->sockaddr == NULL) {
             ngx_close_accepted_connection(c);               
    50. return; c->sockaddr, sa, socklen); 🎜>(ngx_log_t));
    51. > ngx_close_accepted_connection(c);
    52. 🎜>
    }  
99.   
100.         /* einen Blockierungsmodus für AIO und einen nicht blockierenden Modus für andere festlegen.*/
101.   
102.         if (ngx_inherited_nonblocking) {  
103.             if (ngx_event_flags & NGX_USE_AIO_EVENT) {  
104.                 if (ngx_blocking( s) == -1) {  
105.                     ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_socket_errno,  
106.                                   ngx_blocking_n " fehlgeschlagen");  
107.                     ngx_close_accepted_connection(c);  
108.                     Rückgabe;  
109.                 }  
110.             }  
111.   
112.         } else {  
113.             //我们使用epoll模型，这里我们设置连接为nonblocking  
114.             >                if
 (ngx_nonblocking(s) == -1) {  
115.                     ngx_log_error(NG X_LOG_ALERT, ev->log , ngx_socket_errno,  
116.                                  ngx_nonblocking_n " fehlgeschlagen"
);  
117.                     ngx_close_accepted_connection(c);  
118.                     Rückgabe
;  
119.                 }  
120.             }  
121.         }  
122.   
123.         *log = ls->log;  
124.         //初始化新的连接  
125.         c->recv = ngx_recv;  
126.         c->send = ngx_send;  
127.         c->recv_chain = ngx_recv_chain;  
128.         c->send_chain = ngx_send_chain;  
129.   
130.         c->log = log;  
131.         c->pool->log = log;  
132.   
133.         c->socklen = socklen;  
134.         c->listening = ls;  
135.         c->local_sockaddr = ls->sockaddr;  
136.   
137.         c->unexpected_eof = 1;  
138.   
139. #if (NGX_HAVE_UNIX_DOMAIN)  
140. if (c- & gt; sockaddr- & gt; sa_family == af_unix) {
141. c- & gt; tcp_nopush = ngx_tcp_nopush_disabled ;  
142.             c->tcp_nodelay = NGX_TCP_NODELAY_DISABLED;  
143. #if (NGX_SOLARIS)  
144.             /* Solaris's sendfilev() unterstützt AF_NCA, AF_INET und AF_INET6 */  
145.             c->sendfile = 0;  
146. #endif  
147.         }  
148. #endif  
149.   
150.         rev = c->read;  
151.         wev = c->write;  
152.   
153.         wev->ready = 1;  
154.   
155.         if (ngx_event_flags & (NGX_USE_AIO_EVENT|NGX_USE_RTSIG_EVENT)) {  
156.             /* rtsig, aio, iocp */  
157.             rev->ready = 1;  
158.         }  
159.   
160.         if (ev- >deferred_accept) {  
161.             rev->ready = 1;  
162. #if (NGX_HAVE_KQUEUE)  
163.             rev->available = 1;  
164. #endif  
165.         }  
166.   
167.         rev->log = log;  
168.         wev->log = log;  
169.   
170.         /* 
171.          * TODO: MT: - ngx_atomic_fetch_add() 
172.          *             oder Schutz durch kritischen Abschnitt oder leichten Mutex 
173.          * 
174.          * - ngx_atomic_fetch_add() 
175.          *             oder Schutz durch kritischen Abschnitt oder leichten Mutex 
176.          * /  
177.   
        c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);  
          
        
180. if (ngx_add_conn && (ngx_event_flags & NGX_USE_EPOL_EVENT) == 0 ) {  
181.             if (ngx_add_conn(c) == NGX_ERROR) {  
182.                 ngx _close_accepted_connection(c );  
                
183. Rückgabe;  
184.             }  
        }  
  
        log->data = NULL;  
        log->handler = NULL;  
188. >
          很重要，它将完成新连接的最后初始化工作，
189.  
190.         同时将accept到的新的连接放入epoll中；挂在这个handler上的函数， 
191.         🎜>
        */
192.   
193.         ls->handler(c);    
194.         if
 (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {  
195.             ev->verfügbar--;  
196.         }  
197.   
198.     } während (ev ->verfügbar);  
199. }  
acpt事件的handler方法也就是如此了.之后就是每个连接的读写事件handler方法,这一部分会直接将我们引入http模块,我们还不急,还要学习下nginx经典模块epoll。

201. Das Obige stellt die Nginx-Quellcode-Studiennotizen (21) vor – Ereignismodul 2 – den ereignisgesteuerten Kern ngx_process_events_and_timers, einschließlich Warteschlangeninhalten. Ich hoffe, dass es für Freunde hilfreich sein wird, die an PHP-Tutorials interessiert sind.