typedef enum { NGX_HTTP_POST_READ_PHASE = 0, //目前只有realip模塊會注冊handler（nginx作為代理服務器時有用，后端以此獲取客戶端原始ip）  NGX_HTTP_SERVER_REWRITE_PHASE, //server塊中配置了rewrite指令，重寫url  NGX_HTTP_FIND_CONFIG_PHASE, //查找匹配location；不能自定義handler； NGX_HTTP_REWRITE_PHASE,  //location塊中配置了rewrite指令，重寫url NGX_HTTP_POST_REWRITE_PHASE, //檢查是否發生了url重寫，如果有，重新回到FIND_CONFIG階段；不能自定義handler；  NGX_HTTP_PREACCESS_PHASE,  //訪問控制，限流模塊會注冊handler到此階段  NGX_HTTP_ACCESS_PHASE,  //訪問權限控制 NGX_HTTP_POST_ACCESS_PHASE, //根據訪問權限控制階段做相應處理；不能自定義handler；  NGX_HTTP_TRY_FILES_PHASE,  //只有配置了try_files指令，才會有此階段；不能自定義handler； NGX_HTTP_CONTENT_PHASE,  //內容產生階段，返回響應給客戶端  NGX_HTTP_LOG_PHASE   //日志記錄} ngx_http_phases;

typedef struct { ngx_int_t (*preconfiguration)(ngx_conf_t *cf); ngx_int_t (*postconfiguration)(ngx_conf_t *cf); //此方法注冊handler到相應階段  void  *(*create_main_conf)(ngx_conf_t *cf); //http塊中的主配置 char  *(*init_main_conf)(ngx_conf_t *cf, void *conf);  void  *(*create_srv_conf)(ngx_conf_t *cf); //server配置 char  *(*merge_srv_conf)(ngx_conf_t *cf, void *prev, void *conf);  void  *(*create_loc_conf)(ngx_conf_t *cf); //location配置 char  *(*merge_loc_conf)(ngx_conf_t *cf, void *prev, void *conf);} ngx_http_module_t;

static ngx_int_t ngx_http_limit_req_init(ngx_conf_t *cf){ h = ngx_array_push(&cmcf->phases[NGX_HTTP_PREACCESS_PHASE].handlers);  *h = ngx_http_limit_req_handler; //ngx_http_limit_req_module模塊的限流方法；nginx處理HTTP請求時，都會調用此方法判斷應該繼續執行還是拒絕請求  return NGX_OK;}

static ngx_int_t ngx_epoll_add_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags);

struct ngx_event_s {  ngx_event_handler_pt handler; //函數指針：事件的處理函數  ngx_rbtree_node_t timer;  //超時定時器，存儲在紅黑樹中（節點的key即為事件的超時時間）  unsigned   timedout:1; //記錄事件是否超時 };

ngx_msec_t ngx_event_find_timer(void){ node = ngx_rbtree_min(root, sentinel); timer = (ngx_msec_int_t) (node->key - ngx_current_msec);  return (ngx_msec_t) (timer > 0 ? timer : 0);}

void ngx_event_expire_timers(void){ for ( ;; ) {  node = ngx_rbtree_min(root, sentinel);   if ((ngx_msec_int_t) (node->key - ngx_current_msec) <= 0) { //當前事件已經超時   ev = (ngx_event_t *) ((char *) node - offsetof(ngx_event_t, timer));    ev->timedout = 1;    ev->handler(ev);    continue;  }   break; }}

//每個配置指令主要包含兩個字段：名稱，解析配置的處理方法static ngx_command_t ngx_http_limit_req_commands[] = {  //一般用法：limit_req_zone $binary_remote_addr zone=one:10m rate=1r/s; //$binary_remote_addr表示遠程客戶端IP； //zone配置一個存儲空間（需要分配空間記錄每個客戶端的訪問速率，超時空間限制使用lru算法淘汰；注意此空間是在共享內存分配的，所有worker進程都能訪問） //rate表示限制速率，此例為1qps { ngx_string("limit_req_zone"),  ngx_http_limit_req_zone,  },  //用法：limit_req zone=one burst=5 nodelay; //zone指定使用哪一個共享空間 //超出此速率的請求是直接丟棄嗎？burst配置用于處理突發流量，表示最大排隊請求數目，當客戶端請求速率超過限流速率時，請求會排隊等待；而超出burst的才會被直接拒絕； //nodelay必須與burst一起使用；此時排隊等待的請求會被優先處理；否則假如這些請求依然按照限流速度處理，可能等到服務器處理完成后，客戶端早已超時 { ngx_string("limit_req"),  ngx_http_limit_req,  },  //當請求被限流時，日志記錄級別；用法：limit_req_log_level info | notice | warn | error; { ngx_string("limit_req_log_level"),  ngx_conf_set_enum_slot,  },  //當請求被限流時，給客戶端返回的狀態碼；用法：limit_req_status 503 { ngx_string("limit_req_status"),  ngx_conf_set_num_slot, },};

static ngx_http_variable_t ngx_http_core_variables[] = {  { ngx_string("http_host"), NULL, ngx_http_variable_header,  offsetof(ngx_http_request_t, headers_in.host), 0, 0 },  { ngx_string("http_user_agent"), NULL, ngx_http_variable_header,  offsetof(ngx_http_request_t, headers_in.user_agent), 0, 0 }, …………}

typedef struct { ngx_http_limit_req_shctx_t *sh; ngx_slab_pool_t    *shpool;//內存池 ngx_uint_t     rate; //限流速度（qps乘以1000存儲） ngx_int_t     index; //變量索引（nginx提供了一系列變量，用戶配置的限流變量索引） ngx_str_t     var; //限流變量名稱 ngx_http_limit_req_node_t *node;} ngx_http_limit_req_ctx_t; //同時會初始化共享存儲空間struct ngx_shm_zone_s { void      *data; //data指向ngx_http_limit_req_ctx_t結構 ngx_shm_t     shm; //共享空間 ngx_shm_zone_init_pt  init; //初始化方法函數指針 void      *tag; //指向ngx_http_limit_req_module結構體};

typedef struct { ngx_shm_zone_t    *shm_zone; //共享存儲空間   ngx_uint_t     burst;  //隊列大小 ngx_uint_t     nodelay; //有請求排隊時是否緊急處理，與burst配合使用（如果配置，則會緊急處理排隊請求，否則依然按照限流速度處理）} ngx_http_limit_req_limit_t;

//記錄結構體typedef struct { u_char      color; u_char      dummy; u_short      len; //數據長度 ngx_queue_t     queue;  ngx_msec_t     last; //上次訪問時間   ngx_uint_t     excess; //當前剩余待處理的請求數（nginx用此實現令牌桶限流算法） ngx_uint_t     count; //此類記錄請求的總數 u_char      data[1];//數據內容（先按照key（hash值）查找，再比較數據內容是否相等）} ngx_http_limit_req_node_t; //紅黑樹節點，key為用戶配置限流變量的hash值；struct ngx_rbtree_node_s { ngx_rbtree_key_t  key; ngx_rbtree_node_t  *left; ngx_rbtree_node_t  *right; ngx_rbtree_node_t  *parent; u_char     color; u_char     data;};  typedef struct { ngx_rbtree_t     rbtree; //紅黑樹 ngx_rbtree_node_t    sentinel; //NIL節點 ngx_queue_t     queue; //LRU隊列} ngx_http_limit_req_shctx_t; //隊列只有prev和next指針struct ngx_queue_s { ngx_queue_t *prev; ngx_queue_t *next;};

ngx_http_limit_req_ctx_t *ctx;ngx_queue_t    *q; q = ngx_queue_last(&ctx->sh->queue); lr = ngx_queue_data(q, ngx_http_limit_req_node_t, queue);//此方法由ngx_queue_t獲取ngx_http_limit_req_node_t結構首地址，實現如下： #define ngx_queue_data(q, type, link) (type *) ((u_char *) q - offsetof(type, link)) //queue字段地址減去其在結構體中偏移，為結構體首地址

size = offsetof(ngx_rbtree_node_t, color) //新建記錄分配內存，計算所需空間大小  + offsetof(ngx_http_limit_req_node_t, data)  + len; node = ngx_slab_alloc_locked(ctx->shpool, size); node->key = hash; lr = (ngx_http_limit_req_node_t *) &node->color; //color為u_char類型，為什么能強制轉換為ngx_http_limit_req_node_t指針類型呢？ lr->len = (u_char) len;lr->excess = 0; ngx_memcpy(lr->data, data, len); ngx_rbtree_insert(&ctx->sh->rbtree, node); ngx_queue_insert_head(&ctx->sh->queue, &lr->queue);

//limit，限流策略；hash，記錄key的hash值；data，記錄key的數據內容；len，記錄key的數據長度；ep，待處理請求數目；account，是否是最后一條限流策略static ngx_int_t ngx_http_limit_req_lookup(ngx_http_limit_req_limit_t *limit, ngx_uint_t hash, u_char *data, size_t len, ngx_uint_t *ep, ngx_uint_t account){ //紅黑樹查找指定界定 while (node != sentinel) {   if (hash < node->key) {   node = node->left;   continue;  }   if (hash > node->key) {   node = node->right;   continue;  }   //hash值相等，比較數據是否相等  lr = (ngx_http_limit_req_node_t *) &node->color;   rc = ngx_memn2cmp(data, lr->data, len, (size_t) lr->len);  //查找到  if (rc == 0) {   ngx_queue_remove(&lr->queue);   ngx_queue_insert_head(&ctx->sh->queue, &lr->queue); //將記錄移動到LRU隊列頭部     ms = (ngx_msec_int_t) (now - lr->last); //當前時間減去上次訪問時間    excess = lr->excess - ctx->rate * ngx_abs(ms) / 1000 + 1000; //待處理請求書-限流速率*時間段+1個請求（速率，請求數等都乘以1000了）    if (excess < 0) {    excess = 0;   }    *ep = excess;    //待處理數目超過burst（等待隊列大小），返回NGX_BUSY拒絕請求（沒有配置burst時，值為0）   if ((ngx_uint_t) excess > limit->burst) {    return NGX_BUSY;   }    if (account) { //如果是最后一條限流策略，則更新上次訪問時間，待處理請求數目，返回NGX_OK    lr->excess = excess;    lr->last = now;    return NGX_OK;   }   //訪問次數遞增   lr->count++;    ctx->node = lr;    return NGX_AGAIN; //非最后一條限流策略，返回NGX_AGAIN，繼續校驗下一條限流策略  }   node = (rc < 0) ? node->left : node->right; }  //假如沒有查找到節點，需要新建一條記錄 *ep = 0; //存儲空間大小計算方法參照3.2.1節數據結構 size = offsetof(ngx_rbtree_node_t, color)   + offsetof(ngx_http_limit_req_node_t, data)   + len; //嘗試淘汰記錄（LRU） ngx_http_limit_req_expire(ctx, 1);    node = ngx_slab_alloc_locked(ctx->shpool, size);//分配空間 if (node == NULL) { //空間不足，分配失敗  ngx_http_limit_req_expire(ctx, 0); //強制淘汰記錄   node = ngx_slab_alloc_locked(ctx->shpool, size); //分配空間  if (node == NULL) { //分配失敗，返回NGX_ERROR   return NGX_ERROR;  } }  node->key = hash; //賦值 lr = (ngx_http_limit_req_node_t *) &node->color; lr->len = (u_char) len; lr->excess = 0; ngx_memcpy(lr->data, data, len);  ngx_rbtree_insert(&ctx->sh->rbtree, node); //插入記錄到紅黑樹與LRU隊列 ngx_queue_insert_head(&ctx->sh->queue, &lr->queue);  if (account) { //如果是最后一條限流策略，則更新上次訪問時間，待處理請求數目，返回NGX_OK  lr->last = now;  lr->count = 0;  return NGX_OK; }  lr->last = 0; lr->count = 1;  ctx->node = lr;  return NGX_AGAIN; //非最后一條限流策略，返回NGX_AGAIN，繼續校驗下一條限流策略  }

static void ngx_http_limit_req_expire(ngx_http_limit_req_ctx_t *ctx, ngx_uint_t n){ //最多刪除3條記錄 while (n < 3) {  //尾部節點  q = ngx_queue_last(&ctx->sh->queue);  //獲取記錄  lr = ngx_queue_data(q, ngx_http_limit_req_node_t, queue);     //注意：當為0時，無法進入if代碼塊，因此一定會刪除尾部節點；當n不為0時，進入if代碼塊，校驗是否可以刪除  if (n++ != 0) {    ms = (ngx_msec_int_t) (now - lr->last);   ms = ngx_abs(ms);   //短時間內被訪問，不能刪除，直接返回   if (ms < 60000) {    return;   }       //有待處理請求，不能刪除，直接返回   excess = lr->excess - ctx->rate * ms / 1000;   if (excess > 0) {    return;   }  }   //刪除  ngx_queue_remove(q);   node = (ngx_rbtree_node_t *)     ((u_char *) lr - offsetof(ngx_rbtree_node_t, color));   ngx_rbtree_delete(&ctx->sh->rbtree, node);   ngx_slab_free_locked(ctx->shpool, node); }}

//計算當前請求還需要排隊多久才能處理delay = ngx_http_limit_req_account(limits, n, &excess, &limit);//添加可讀事件if (ngx_handle_read_event(r->connection->read, 0) != NGX_OK) { return NGX_HTTP_INTERNAL_SERVER_ERROR;}r->read_event_handler = ngx_http_test_reading;r->write_event_handler = ngx_http_limit_req_delay; //可寫事件處理函數ngx_add_timer(r->connection->write, delay); //可寫事件添加定時器（超時之前是不能往客戶端返回的）

if (limits[n].nodelay) { //配置了nodelay時，請求不會被延時處理，delay為0 continue;} delay = excess * 1000 / ctx->rate; if (delay > max_delay) { max_delay = delay; *ep = excess; *limit = &limits[n];}

static void ngx_http_limit_req_delay(ngx_http_request_t *r){  wev = r->connection->write;  if (!wev->timedout) { //沒有超時不會處理   if (ngx_handle_write_event(wev, 0) != NGX_OK) {   ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);  }   return; }  wev->timedout = 0;  r->read_event_handler = ngx_http_block_reading; r->write_event_handler = ngx_http_core_run_phases;  ngx_http_core_run_phases(r); //超時了，繼續處理HTTP請求}

http{ limit_req_zone $binary_remote_addr zone=test:10m rate=1r/s;  server {  listen  80;  server_name localhost;  location / {   limit_req zone=test;   root html;   index index.html index.htm;  }}

http{ limit_req_zone $binary_remote_addr zone=test:10m rate=1r/s;  server {  listen  80;  server_name localhost;  location / {   limit_req zone=test burst=5;   root html;   index index.html index.htm;  }}

    min mean[+/-sd] median maxConnect:  41 44 1.7  44  46Processing: 46 1566 1916.6 1093 5084Waiting:  46 1565 1916.7 1092 5084Total:   87 1609 1916.2 1135 5128

http{ limit_req_zone $binary_remote_addr zone=test:10m rate=1r/s;  server {  listen  80;  server_name localhost;  location / {   limit_req zone=test burst=5 nodelay;   root html;   index index.html index.htm;  }}

    min mean[+/-sd] median maxConnect:  42 43 0.5  43  43Processing: 43 46 2.4  47  49Waiting:  42 45 2.5  46  49Total:   85 88 2.8  90  92