Nginx における accept lock の仕組みと実装の詳細な説明

ngx_shmtx_t ngx_accept_mutex;

静的 ngx_inline ngx_uint_t             
ngx_shmtx_trylock(ngx_shmtx_t *mtx)           
{                    
 戻り値 (*mtx->lock == 0 && ngx_atomic_cmp_set(mtx->lock, 0, ngx_pid));  
}                    
                    
#define ngx_shmtx_lock(mtx) ngx_spinlock((mtx)->lock, ngx_pid, 1024)   
                    
#define ngx_shmtx_unlock(mtx) (void) ngx_atomic_cmp_set((mtx)->lock, ngx_pid, 0)

ngx_thread_volatile ngx_event_t *ngx_posted_accept_events;        
ngx_thread_volatile ngx_event_t *ngx_posted_events;

空所                   
ngx_process_events_and_timers(ngx_cycle_t *サイクル)        
{                    
 ngx_uint_t フラグ;               
 ngx_msec_t タイマー、デルタ;             
    
	
	/* 時間イベントを処理するためのコードを省略*/                    
 // ここで負荷分散ロックを処理し、ロックを受け入れる if (ngx_use_accept_mutex) {            
  // 負荷分散トークンの値が 0 より大きい場合、負荷がいっぱいで accept が処理されなくなったことを意味します。同時に、値は 1 減少します if (ngx_accept_disabled > 0) {           
   ngx_accept_disabled--;            
                    
  } それ以外 {                
   // 受け入れロックを取得しようとする if (ngx_trylock_accept_mutex(cycle) == NGX_ERROR) {    
    戻る;              
   }                 
                    
   // ロックを取得した後、すべてのイベントの処理を延期するためにフラグをポストフラグに追加します // 受け入れロックを長時間占有しないようにします if (ngx_accept_mutex_held) {          
    フラグ |= NGX_POST_EVENTS;          
                    
   } それ以外 {               
    タイマー == NGX_TIMER_INFINITE の場合        
     || タイマー > ngx_accept_mutex_delay)       
    {                
     timer = ngx_accept_mutex_delay; // 受け入れロックが長時間占有されるのを防ぐために、最大で ngx_accept_mutex_delay ミリ秒待機します}                
   }                 
  }                  
 }                    
 デルタ = ngx_current_msec;             
                    
 // イベント処理モジュールの process_events を呼び出して、epoll_wait メソッドを処理します (void) ngx_process_events(cycle, timer, flags);       
                    
 delta = ngx_current_msec - delta; //イベントの処理にかかった時間を計算 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,       
     "タイマーデルタ: %M", デルタ);         
                    
 // 延期された承諾イベントがある場合は、このイベントの処理を延期します if (ngx_posted_accept_events) {           
  ngx_event_process_posted(サイクル、&ngx_posted_accept_events);   
 }                   
                    
 // accept ロックを解除する if (ngx_accept_mutex_held) {            
  ngx_shmtx_unlock(&ngx_accept_mutex);         
 }                   
                    
 // すべてのタイムアウトイベントを処理する if (delta) {                
  ngx_event_expire_timers();            
 }                   
                    
 ngx_log_debug1(NGX_LOG_DEBUG_EVENT、サイクル->ログ、0、       
     "投稿されたイベント %p", ngx_posted_events);      
                    
 ngx_posted_eventsの場合{             
  ngx_threadedの場合{             
   ngx_wakeup_worker_thread(サイクル);         
                    
  } それ以外 {                
   // すべての遅延イベントを処理する ngx_event_process_posted(cycle, &ngx_posted_events);    
  }                  
 }                   
}

  // イベントを読み取る if ((revents & EPOLLIN) && rev->active) {
   if ((フラグ & NGX_POST_THREAD_EVENTS) && !rev->accept) {
    rev->posted_ready = 1;

   } それ以外 {
    回転->準備完了 = 1;
   }                                        
   if (フラグ & NGX_POST_EVENTS) {
    キュー = (ngx_event_t **) (rev->accept ?
        &ngx_posted_accept_events : &ngx_posted_events);
    ngx_locked_post_event(rev、キュー);
   } それ以外 {
    rev->ハンドラ(rev);
   }
  }                                         
  wev = c->書き込み;

  // イベントを書き込む if ((revents & EPOLLOUT) && wev->active) {
   if (フラグ & NGX_POST_THREAD_EVENTS) {
    wev->posted_ready = 1;
   } それ以外 {
    wev->準備完了 = 1;
   }

   if (フラグ & NGX_POST_EVENTS) {
    ngx_locked_post_event(wev、&ngx_posted_events);
   } それ以外 {
    wev->ハンドラ(wev);
   }
  }