主頁(yè) > 知識(shí)庫(kù) > nginx共享內(nèi)存機(jī)制詳解

nginx共享內(nèi)存機(jī)制詳解

熱門(mén)標(biāo)簽:400電話申請(qǐng)知乎 400電話干嘛怎么申請(qǐng)信用卡 接電話機(jī)器人罵人 代理外呼系統(tǒng)創(chuàng)業(yè) 外呼系統(tǒng)虛擬號(hào)碼 泰州智能外呼系統(tǒng)排名 百度地圖標(biāo)注尺寸無(wú)法顯示 大連電銷外呼系統(tǒng)運(yùn)營(yíng)商 長(zhǎng)春電銷外呼系統(tǒng)代理商

nginx的共享內(nèi)存,是其能夠?qū)崿F(xiàn)高性能的主要原因之一,而其主要是用于對(duì)文件的緩存。本文首先會(huì)講解共享內(nèi)存的使用方式,然后會(huì)講解nginx是如何實(shí)現(xiàn)共享內(nèi)存的管理的。

1. 使用示例

nginx聲明共享內(nèi)存的指令為:

proxy_cache_path /Users/Mike/nginx-cache levels=1:2 keys_zone=one:10m max_size=10g inactive=60m use_temp_path=off;

這里只是聲明的一個(gè)名稱為one,最大可用內(nèi)存為10g的共享內(nèi)存。這里面各個(gè)參數(shù)的含義如下:

  • /Users/Mike/nginx-cache:這是一個(gè)路徑參數(shù),指定了將共享內(nèi)存所緩存的文件的存儲(chǔ)位置。這里為什么會(huì)生成文件的原因在于,對(duì)于上游服務(wù)發(fā)出的響應(yīng),是可以將其生成一個(gè)文件存儲(chǔ)在nginx上的,后續(xù)如果有同樣的請(qǐng)求,就可以直接讀取該文件或者讀取共享內(nèi)存中的緩存以響應(yīng)客戶端;
  • levels:在linux操作系統(tǒng)中,如果所有文件都放在一個(gè)文件夾中,那么當(dāng)文件數(shù)量非常多的時(shí)候,可能一個(gè)磁盤(pán)驅(qū)動(dòng)就無(wú)法讀取這么多文件了,如果放置在多個(gè)文件夾中,那么就能夠利用多個(gè)驅(qū)動(dòng)并且讀取的優(yōu)點(diǎn)。這里的levels參數(shù)指定的就是如何生成文件夾。假設(shè)nginx為上游服務(wù)的某個(gè)響應(yīng)數(shù)據(jù)生成的文件名為e0bd86606797639426a92306b1b98ad9,那么對(duì)于上面的levels=1:2,其就會(huì)從文件名的最后開(kāi)始取值,先取1位(也即9)作為一級(jí)子目錄名,然后取2位(也即ad)作為二級(jí)子目錄名;
  • keys_zone:該參數(shù)指定了當(dāng)前共享內(nèi)存的名稱,這里為one,后面的10m表示當(dāng)前共享內(nèi)存用于存儲(chǔ)key的內(nèi)存大小為10m;
  • max_size:該參數(shù)指定了當(dāng)前共享內(nèi)存可用的最大內(nèi)存;
  • inactive:該參數(shù)指定了當(dāng)前共享內(nèi)存的最長(zhǎng)存活時(shí)間,如果在這段時(shí)間內(nèi)都沒(méi)有任何請(qǐng)求訪問(wèn)該內(nèi)存數(shù)據(jù),那么其就會(huì)被LRU算法淘汰掉;
  • use_temp_path:該參數(shù)指定了是否先將生成的文件放入臨時(shí)文件夾,后續(xù)再移動(dòng)到指定文件夾下;

2. 工作原理

共享內(nèi)存的管理工作主要分為如下圖所示的幾個(gè)部分:

可以看到,其主要分為初始化、共享內(nèi)存的管理、共享內(nèi)存的加載和共享內(nèi)存的使用等幾個(gè)方面。在初始化的過(guò)程中,首先會(huì)解析proxy_cache_path指令,然后分別啟動(dòng)cache manager和cache loader進(jìn)程;這里cache manager進(jìn)程主要是進(jìn)行共享內(nèi)存的管理的,其主要是通過(guò)LRU算法清除過(guò)期數(shù)據(jù),或者當(dāng)資源緊張時(shí)強(qiáng)制刪除部分未被引用的內(nèi)存數(shù)據(jù);而cache loader進(jìn)程的主要工作是在nginx啟動(dòng)之后,讀取文件存儲(chǔ)目錄中已有的文件,將其加載到共享內(nèi)存中;而共享內(nèi)存的使用主要是在處理請(qǐng)求完成之后對(duì)響應(yīng)數(shù)據(jù)的緩存,這一部分的內(nèi)容將在后面的文章中進(jìn)行講解,本文主要講解前面三部分的工作原理。

按照上面的劃分,共享內(nèi)存的管理主要可以分為三個(gè)部分(共享內(nèi)存的使用將在后面進(jìn)行講解)。如下是這三個(gè)部分的處理流程的示意圖:

從上面的流程圖中可以看出,在主流程中,主要進(jìn)行了解析proxy_cache_path指令、啟動(dòng)cache manager進(jìn)程和啟動(dòng)cache loader進(jìn)程的工作。而在cache manager進(jìn)程中,主要工作則分為兩部分:1. 檢查隊(duì)列尾部元素是否過(guò)期,如果過(guò)期并且引用數(shù)為0,則刪除該元素和該元素對(duì)應(yīng)的文件;2. 檢查當(dāng)前共享內(nèi)存是否資源緊張,如果資源緊張,則刪除所有引用數(shù)為0的元素及其文件,無(wú)論其是否過(guò)期。在cache loader進(jìn)程的處理流程中,主要是通過(guò)遞歸的方式遍歷存儲(chǔ)文件的目錄及其子目錄中的文件,然后將這些文件加載到共享內(nèi)存中。需要注意的是,cache manager進(jìn)程在每次遍歷完所有的共享內(nèi)存塊之后會(huì)進(jìn)入下一次循環(huán),而cache loader進(jìn)程在nginx啟動(dòng)之后60s的時(shí)刻執(zhí)行一次,然后就會(huì)退出該進(jìn)程。

3. 源碼解讀

3.1 proxy_cache_path指令解析

對(duì)于nginx各個(gè)指令的解析,其都會(huì)在相應(yīng)的模塊中定義一個(gè)ngx_command_t結(jié)構(gòu)體,該結(jié)構(gòu)體中有一個(gè)set方法指定了解析當(dāng)前指令所使用的方法。如下是proxy_cache_path所對(duì)應(yīng)的ngx_command_t結(jié)構(gòu)體的定義:

static ngx_command_t ngx_http_proxy_commands[] = {
 { ngx_string("proxy_cache_path"), // 指定了當(dāng)前指令的名稱
  // 指定了當(dāng)前指令的使用位置,即http模塊,并且指定了當(dāng)前模塊的參數(shù)個(gè)數(shù),這里是必須大于等于2
   NGX_HTTP_MAIN_CONF|NGX_CONF_2MORE,
  // 指定了set()方法所指向的方法
   ngx_http_file_cache_set_slot,
   NGX_HTTP_MAIN_CONF_OFFSET,
   offsetof(ngx_http_proxy_main_conf_t, caches),
   &ngx_http_proxy_module }
}

可以看到,該指令所使用的解析方法是ngx_http_file_cache_set_slot(),這里我們直接閱讀該方法的源碼:

char *ngx_http_file_cache_set_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
  char *confp = conf;

  off_t          max_size;
  u_char         *last, *p;
  time_t         inactive;
  ssize_t         size;
  ngx_str_t        s, name, *value;
  ngx_int_t        loader_files, manager_files;
  ngx_msec_t       loader_sleep, manager_sleep, loader_threshold,
              manager_threshold;
  ngx_uint_t       i, n, use_temp_path;
  ngx_array_t      *caches;
  ngx_http_file_cache_t *cache, **ce;

  cache = ngx_pcalloc(cf->pool, sizeof(ngx_http_file_cache_t));
  if (cache == NULL) {
    return NGX_CONF_ERROR;
  }

  cache->path = ngx_pcalloc(cf->pool, sizeof(ngx_path_t));
  if (cache->path == NULL) {
    return NGX_CONF_ERROR;
  }

  // 初始化各個(gè)屬性的默認(rèn)值
  use_temp_path = 1;

  inactive = 600;

  loader_files = 100;
  loader_sleep = 50;
  loader_threshold = 200;

  manager_files = 100;
  manager_sleep = 50;
  manager_threshold = 200;

  name.len = 0;
  size = 0;
  max_size = NGX_MAX_OFF_T_VALUE;

  // 示例配置:proxy_cache_path /Users/Mike/nginx-cache levels=1:2 keys_zone=one:10m max_size=10g inactive=60m use_temp_path=off;

  // 這里的cf->args->elts中存儲(chǔ)了解析proxy_cache_path指令時(shí),其包含的各個(gè)token項(xiàng),
  // 所謂的token項(xiàng),指的就是使用空格分隔的字符片段
  value = cf->args->elts;

  // value[1]就是配置的第一個(gè)參數(shù),也即cache文件會(huì)保存的根路徑
  cache->path->name = value[1];

  if (cache->path->name.data[cache->path->name.len - 1] == '/') {
    cache->path->name.len--;
  }

  if (ngx_conf_full_name(cf->cycle, &cache->path->name, 0) != NGX_OK) {
    return NGX_CONF_ERROR;
  }

  // 從第三個(gè)參數(shù)開(kāi)始進(jìn)行解析
  for (i = 2; i < cf->args->nelts; i++) {

    // 如果第三個(gè)參數(shù)是以"levels="開(kāi)頭,則解析levels子參數(shù)
    if (ngx_strncmp(value[i].data, "levels=", 7) == 0) {

      p = value[i].data + 7; // 計(jì)算開(kāi)始解析的其實(shí)位置
      last = value[i].data + value[i].len;  // 計(jì)算最后一個(gè)字符的位置

      // 開(kāi)始解析1:2
      for (n = 0; n < NGX_MAX_PATH_LEVEL && p < last; n++) {

        if (*p > '0' && *p < '3') {

          // 獲取當(dāng)前的參數(shù)值,比如需要解析的1和2
          cache->path->level[n] = *p++ - '0';
          cache->path->len += cache->path->level[n] + 1;

          if (p == last) {
            break;
          }

          // 如果當(dāng)前字符是冒號(hào),則繼續(xù)下一個(gè)字符的解析;
          // 這里的NGX_MAX_PATH_LEVEL值為3,也就是說(shuō)levels參數(shù)后最多接3級(jí)子目錄
          if (*p++ == ':' && n < NGX_MAX_PATH_LEVEL - 1 && p < last) {
            continue;
          }

          goto invalid_levels;
        }

        goto invalid_levels;
      }

      if (cache->path->len < 10 + NGX_MAX_PATH_LEVEL) {
        continue;
      }

    invalid_levels:

      ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                "invalid \"levels\" \"%V\"", &value[i]);
      return NGX_CONF_ERROR;
    }

    // 如果當(dāng)前的參數(shù)是以"use_temp_path="開(kāi)頭,則解析use_temp_path參數(shù),該參數(shù)值為on或者off,
    // 表示當(dāng)前緩存文件是否首先存入臨時(shí)文件夾中,最后再寫(xiě)入到目標(biāo)文件夾中,如果為off則直接存入目標(biāo)文件夾
    if (ngx_strncmp(value[i].data, "use_temp_path=", 14) == 0) {

      // 如果為on,則標(biāo)記use_temp_path為1
      if (ngx_strcmp(&value[i].data[14], "on") == 0) {
        use_temp_path = 1;

        // 如果為off,則標(biāo)記use_temp_path為0
      } else if (ngx_strcmp(&value[i].data[14], "off") == 0) {
        use_temp_path = 0;

        // 如果都不止,則返回解析異常
      } else {
        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                  "invalid use_temp_path value \"%V\", "
                  "it must be \"on\" or \"off\"",
                  &value[i]);
        return NGX_CONF_ERROR;
      }

      continue;
    }

    // 如果參數(shù)是以"keys_zone="開(kāi)頭,則解析keys_zone參數(shù)。該參數(shù)的形式如keys_zone=one:10m,
    // 這里的one是一個(gè)名稱,以供給后續(xù)的location配置使用,而10m則是一個(gè)大小,
    // 表示供給存儲(chǔ)key的緩存大小
    if (ngx_strncmp(value[i].data, "keys_zone=", 10) == 0) {

      name.data = value[i].data + 10;

      p = (u_char *) ngx_strchr(name.data, ':');

      if (p) {
        // 計(jì)算name的長(zhǎng)度,name記錄了當(dāng)前的緩存區(qū)的名稱,也即這里的one
        name.len = p - name.data;

        p++;

        // 解析所指定的size大小
        s.len = value[i].data + value[i].len - p;
        s.data = p;

        // 對(duì)大小進(jìn)行解析,會(huì)將指定的大小最終轉(zhuǎn)換為字節(jié)數(shù),這里的字節(jié)數(shù)必須大于8191
        size = ngx_parse_size(&s);
        if (size > 8191) {
          continue;
        }
      }

      ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                "invalid keys zone size \"%V\"", &value[i]);
      return NGX_CONF_ERROR;
    }

    // 如果參數(shù)是以"inactive="開(kāi)頭,則解析inactive參數(shù)。該參數(shù)的形式如inactive=60m,
    // 表示緩存的文件在多長(zhǎng)時(shí)間沒(méi)有訪問(wèn)之后將會(huì)過(guò)期
    if (ngx_strncmp(value[i].data, "inactive=", 9) == 0) {

      s.len = value[i].len - 9;
      s.data = value[i].data + 9;

      // 對(duì)時(shí)間進(jìn)行解析,最終將轉(zhuǎn)換為以秒為單位的時(shí)間長(zhǎng)度
      inactive = ngx_parse_time(&s, 1);
      if (inactive == (time_t) NGX_ERROR) {
        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                  "invalid inactive value \"%V\"", &value[i]);
        return NGX_CONF_ERROR;
      }

      continue;
    }

    // 如果參數(shù)是以"max_size="開(kāi)頭,則解析max_size參數(shù)。該參數(shù)的形式如max_size=10g,
    // 表示當(dāng)前緩存能夠使用的最大內(nèi)存空間
    if (ngx_strncmp(value[i].data, "max_size=", 9) == 0) {

      s.len = value[i].len - 9;
      s.data = value[i].data + 9;

      // 對(duì)解析得到的值進(jìn)行轉(zhuǎn)換,最終將以字節(jié)數(shù)為單位
      max_size = ngx_parse_offset(&s);
      if (max_size < 0) {
        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                  "invalid max_size value \"%V\"", &value[i]);
        return NGX_CONF_ERROR;
      }

      continue;
    }

    // 如果參數(shù)是以"loader_files="開(kāi)頭,則解析loader_files參數(shù)。該參數(shù)形如loader_files=100,
    // 表示在啟動(dòng)nginx的時(shí)候默認(rèn)會(huì)加載多少個(gè)緩存目錄中的文件到緩存中
    if (ngx_strncmp(value[i].data, "loader_files=", 13) == 0) {

      // 解析loader_files參數(shù)的值
      loader_files = ngx_atoi(value[i].data + 13, value[i].len - 13);
      if (loader_files == NGX_ERROR) {
        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
              "invalid loader_files value \"%V\"", &value[i]);
        return NGX_CONF_ERROR;
      }

      continue;
    }

    // 如果參數(shù)是以"loader_sleep="開(kāi)頭,則解析loader_sleep參數(shù)。該參數(shù)形如loader_sleep=10s,
    // 表示每次加載一個(gè)文件之后休眠多長(zhǎng)時(shí)間,然后再加載下一個(gè)文件
    if (ngx_strncmp(value[i].data, "loader_sleep=", 13) == 0) {

      s.len = value[i].len - 13;
      s.data = value[i].data + 13;

      // 對(duì)loader_sleep的值進(jìn)行轉(zhuǎn)換,這里是以毫秒數(shù)為單位
      loader_sleep = ngx_parse_time(&s, 0);
      if (loader_sleep == (ngx_msec_t) NGX_ERROR) {
        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
              "invalid loader_sleep value \"%V\"", &value[i]);
        return NGX_CONF_ERROR;
      }

      continue;
    }

    // 如果參數(shù)是以"loader_threshold="開(kāi)頭,則解析loader_threshold參數(shù),該參數(shù)形如loader_threshold=10s,
    // 表示每次加載一個(gè)文件能夠使用的最長(zhǎng)時(shí)間
    if (ngx_strncmp(value[i].data, "loader_threshold=", 17) == 0) {

      s.len = value[i].len - 17;
      s.data = value[i].data + 17;

      // 對(duì)loader_threshold的值進(jìn)行解析并且轉(zhuǎn)換,最終是以毫秒數(shù)為單位
      loader_threshold = ngx_parse_time(&s, 0);
      if (loader_threshold == (ngx_msec_t) NGX_ERROR) {
        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
              "invalid loader_threshold value \"%V\"", &value[i]);
        return NGX_CONF_ERROR;
      }

      continue;
    }

    // 如果參數(shù)是以"manager_files="開(kāi)頭,則解析manager_files參數(shù),該參數(shù)形如manager_files=100,
    // 表示當(dāng)緩存空間用盡時(shí),將會(huì)以LRU算法將文件進(jìn)行刪除,不過(guò)每次迭代最多刪除manager_files所指定的文件數(shù)
    if (ngx_strncmp(value[i].data, "manager_files=", 14) == 0) {

      // 解析manager_files參數(shù)值
      manager_files = ngx_atoi(value[i].data + 14, value[i].len - 14);
      if (manager_files == NGX_ERROR) {
        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
              "invalid manager_files value \"%V\"", &value[i]);
        return NGX_CONF_ERROR;
      }

      continue;
    }

    // 如果參數(shù)是以"manager_sleep="開(kāi)頭,則解析manager_sleep參數(shù),該參數(shù)形如manager_sleep=1s,
    // 表示每次迭代完成之后將會(huì)休眠manager_sleep參數(shù)所指定的時(shí)長(zhǎng)
    if (ngx_strncmp(value[i].data, "manager_sleep=", 14) == 0) {

      s.len = value[i].len - 14;
      s.data = value[i].data + 14;

      // 對(duì)manager_sleep所指定的值進(jìn)行解析
      manager_sleep = ngx_parse_time(&s, 0);
      if (manager_sleep == (ngx_msec_t) NGX_ERROR) {
        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
              "invalid manager_sleep value \"%V\"", &value[i]);
        return NGX_CONF_ERROR;
      }

      continue;
    }

    // 如果參數(shù)是以"manager_threshold="開(kāi)頭,則解析manager_threshold參數(shù),該參數(shù)形如manager_threshold=2s,
    // 表示每次清除文件的迭代的最長(zhǎng)耗時(shí)不能超過(guò)該參數(shù)所指定的值
    if (ngx_strncmp(value[i].data, "manager_threshold=", 18) == 0) {

      s.len = value[i].len - 18;
      s.data = value[i].data + 18;

      // 解析manager_threshold參數(shù)值,并且將其轉(zhuǎn)換為以毫秒數(shù)為單位的值
      manager_threshold = ngx_parse_time(&s, 0);
      if (manager_threshold == (ngx_msec_t) NGX_ERROR) {
        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
              "invalid manager_threshold value \"%V\"", &value[i]);
        return NGX_CONF_ERROR;
      }

      continue;
    }

    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
              "invalid parameter \"%V\"", &value[i]);
    return NGX_CONF_ERROR;
  }

  if (name.len == 0 || size == 0) {
    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
              "\"%V\" must have \"keys_zone\" parameter",
              &cmd->name);
    return NGX_CONF_ERROR;
  }

  // 這里的cache->path->manager和cache->path->loader的值為兩個(gè)函數(shù),需要注意的是,
  // 在nginx啟動(dòng)之后,會(huì)啟動(dòng)兩個(gè)單獨(dú)的進(jìn)程,一個(gè)cache manager,一個(gè)cache loader,其中cache manager
  // 將會(huì)在一個(gè)循環(huán)中不斷的為每個(gè)共享內(nèi)存執(zhí)行cache->path->manager所指定的方法,
  // 從而實(shí)現(xiàn)對(duì)緩存進(jìn)行清理。而另一個(gè)進(jìn)程cache loader則會(huì)在nginx啟動(dòng)之后60s的時(shí)候只執(zhí)行一次,
  // 執(zhí)行的方法就是cache->path->loader所指定的方法,
  // 該方法的主要作用是加載已經(jīng)存在的文件數(shù)據(jù)到當(dāng)前的共享內(nèi)存中
  cache->path->manager = ngx_http_file_cache_manager;
  cache->path->loader = ngx_http_file_cache_loader;
  cache->path->data = cache;
  cache->path->conf_file = cf->conf_file->file.name.data;
  cache->path->line = cf->conf_file->line;
  cache->loader_files = loader_files;
  cache->loader_sleep = loader_sleep;
  cache->loader_threshold = loader_threshold;
  cache->manager_files = manager_files;
  cache->manager_sleep = manager_sleep;
  cache->manager_threshold = manager_threshold;

  // 將當(dāng)前的path添加到cycle中,后續(xù)會(huì)對(duì)這些path進(jìn)行檢查,如果path不存在,則會(huì)創(chuàng)建相應(yīng)的路徑
  if (ngx_add_path(cf, &cache->path) != NGX_OK) {
    return NGX_CONF_ERROR;
  }

  // 把當(dāng)前共享內(nèi)存添加到cf->cycle->shared_memory所指定的共享內(nèi)存列表中
  cache->shm_zone = ngx_shared_memory_add(cf, &name, size, cmd->post);
  if (cache->shm_zone == NULL) {
    return NGX_CONF_ERROR;
  }

  if (cache->shm_zone->data) {
    ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
              "duplicate zone \"%V\"", &name);
    return NGX_CONF_ERROR;
  }


  // 這里指定了每個(gè)共享內(nèi)存的初始化方法,該方法在master進(jìn)程啟動(dòng)的時(shí)候會(huì)被執(zhí)行
  cache->shm_zone->init = ngx_http_file_cache_init;
  cache->shm_zone->data = cache;

  cache->use_temp_path = use_temp_path;

  cache->inactive = inactive;
  cache->max_size = max_size;

  caches = (ngx_array_t *) (confp + cmd->offset);

  ce = ngx_array_push(caches);
  if (ce == NULL) {
    return NGX_CONF_ERROR;
  }

  *ce = cache;

  return NGX_CONF_OK;
}

 從上面的代碼可以看出,在proxy_cache_path方法中,主要是初始化了一個(gè)ngx_http_file_cache_t結(jié)構(gòu)體。而該結(jié)構(gòu)體中的各個(gè)屬性,則是通過(guò)解析proxy_cache_path的各個(gè)參數(shù)來(lái)進(jìn)行的。

3.2 cache manager與cache loader進(jìn)程啟動(dòng)

nginx程序的入口方法是nginx.c的main()方法,如果開(kāi)啟了master-worker進(jìn)程模式,那么最后就會(huì)進(jìn)入ngx_master_process_cycle()方法,該方法首先會(huì)啟動(dòng)worker進(jìn)程,以接收客戶端的請(qǐng)求;然后會(huì)分別啟動(dòng)cache manager和cache loader進(jìn)程;最后進(jìn)入一個(gè)無(wú)限循環(huán)中,以處理用戶在命令行向nginx發(fā)送的指令。如下是cache manager和cache loader進(jìn)程啟動(dòng)的源碼:

void
ngx_master_process_cycle(ngx_cycle_t *cycle)
{
  ...
   
  // 獲取核心模塊的配置
  ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);

  // 啟動(dòng)各個(gè)worker進(jìn)程
  ngx_start_worker_processes(cycle, ccf->worker_processes, NGX_PROCESS_RESPAWN);
  // 啟動(dòng)cache進(jìn)程
  ngx_start_cache_manager_processes(cycle, 0);
 
  ...
}

 對(duì)于cache manager和cache loader進(jìn)程的啟動(dòng),可以看到,其主要是在ngx_start_cache_manager_processes()方法中,如下是該方法的源碼:

static void ngx_start_cache_manager_processes(ngx_cycle_t *cycle, ngx_uint_t respawn) {
  ngx_uint_t    i, manager, loader;
  ngx_path_t   **path;
  ngx_channel_t  ch;

  manager = 0;
  loader = 0;

  path = ngx_cycle->paths.elts;
  for (i = 0; i < ngx_cycle->paths.nelts; i++) {

    // 查找是否有任何一個(gè)path指定了manager為1
    if (path[i]->manager) {
      manager = 1;
    }

    // 查找是否有任何一個(gè)path指定了loader為1
    if (path[i]->loader) {
      loader = 1;
    }
  }

  // 如果沒(méi)有任何一個(gè)path的manager指定為1,則直接返回
  if (manager == 0) {
    return;
  }

  // 創(chuàng)建一個(gè)進(jìn)程以執(zhí)行ngx_cache_manager_process_cycle()方法中所執(zhí)行的循環(huán),需要注意的是,
  // 在回調(diào)ngx_cache_manager_process_cycle方法時(shí),這里傳入的第二個(gè)參數(shù)是ngx_cache_manager_ctx
  ngx_spawn_process(cycle, ngx_cache_manager_process_cycle,
           &ngx_cache_manager_ctx, "cache manager process",
           respawn ? NGX_PROCESS_JUST_RESPAWN : NGX_PROCESS_RESPAWN);

  ngx_memzero(&ch, sizeof(ngx_channel_t));

  // 創(chuàng)建一個(gè)ch結(jié)構(gòu)體,以將當(dāng)前進(jìn)程的創(chuàng)建消息廣播出去
  ch.command = NGX_CMD_OPEN_CHANNEL;
  ch.pid = ngx_processes[ngx_process_slot].pid;
  ch.slot = ngx_process_slot;
  ch.fd = ngx_processes[ngx_process_slot].channel[0];

  // 廣播cache manager process進(jìn)程被創(chuàng)建的消息
  ngx_pass_open_channel(cycle, &ch);

  if (loader == 0) {
    return;
  }

  // 創(chuàng)建一個(gè)進(jìn)程以執(zhí)行ngx_cache_manager_process_cycle()所指定的流程,需要注意的是,
  // 在回調(diào)ngx_cache_manager_process_cycle方法時(shí),這里傳入的第二個(gè)參數(shù)是ngx_cache_loader_ctx
  ngx_spawn_process(cycle, ngx_cache_manager_process_cycle,
           &ngx_cache_loader_ctx, "cache loader process",
           respawn ? NGX_PROCESS_JUST_SPAWN : NGX_PROCESS_NORESPAWN);

  // 創(chuàng)建一個(gè)ch結(jié)構(gòu)體,以將當(dāng)前進(jìn)程的創(chuàng)建消息廣播出去
  ch.command = NGX_CMD_OPEN_CHANNEL;
  ch.pid = ngx_processes[ngx_process_slot].pid;
  ch.slot = ngx_process_slot;
  ch.fd = ngx_processes[ngx_process_slot].channel[0];

  // 廣播cache loader process進(jìn)程被創(chuàng)建的消息
  ngx_pass_open_channel(cycle, &ch);
}

上面的代碼其實(shí)比較簡(jiǎn)單,首先檢查是否有任何一個(gè)路徑指定了使用cache manager或者cache loader,如果有,則啟動(dòng)對(duì)應(yīng)的繼承,否則是不會(huì)創(chuàng)建cache manager和cache loader進(jìn)程的。而啟動(dòng)這兩個(gè)進(jìn)程所使用的方法都是:

// 啟動(dòng)cache manager進(jìn)程
ngx_spawn_process(cycle, ngx_cache_manager_process_cycle,
         &ngx_cache_manager_ctx, "cache manager process",
         respawn ? NGX_PROCESS_JUST_RESPAWN : NGX_PROCESS_RESPAWN);

// 啟動(dòng)cache loader進(jìn)程
ngx_spawn_process(cycle, ngx_cache_manager_process_cycle,
           &ngx_cache_loader_ctx, "cache loader process",
           respawn ? NGX_PROCESS_JUST_SPAWN : NGX_PROCESS_NORESPAWN);

這里的ngx_spawn_process()方法的作用主要是創(chuàng)建一個(gè)新的進(jìn)程,該進(jìn)程創(chuàng)建之后就會(huì)執(zhí)行第二個(gè)參數(shù)所指定的方法,并且執(zhí)行該方法時(shí)傳入的參數(shù)是這里第三個(gè)參數(shù)所指定的結(jié)構(gòu)體對(duì)象。觀察上面兩個(gè)啟動(dòng)進(jìn)程的方式,其在新進(jìn)程創(chuàng)建之后所執(zhí)行的方法都是ngx_cache_manager_process_cycle(),只不過(guò)調(diào)用該方法時(shí)傳入的參數(shù)不一樣,一個(gè)是ngx_cache_manager_ctx,另一個(gè)則是ngx_cache_loader_ctx。這里我們首先看一下這兩個(gè)結(jié)構(gòu)體的定義:

// 這里的ngx_cache_manager_process_handler指定了當(dāng)前cache manager進(jìn)程將會(huì)執(zhí)行的方法,
// cache manager process則指定了該進(jìn)程的名稱,而最后的0表示當(dāng)前進(jìn)程在啟動(dòng)之后間隔多長(zhǎng)時(shí)間才會(huì)執(zhí)行
// ngx_cache_manager_process_handler()方法,這里是立即執(zhí)行
static ngx_cache_manager_ctx_t ngx_cache_manager_ctx = {
  ngx_cache_manager_process_handler, "cache manager process", 0
};

// 這里的ngx_cache_loader_process_handler指定了當(dāng)前cache loader進(jìn)程將會(huì)執(zhí)行的方法,
// 其會(huì)在cache loader進(jìn)程啟動(dòng)后60秒之后才會(huì)執(zhí)行ngx_cache_loader_process_handler()方法
static ngx_cache_manager_ctx_t ngx_cache_loader_ctx = {
  ngx_cache_loader_process_handler, "cache loader process", 60000
};


可以看到,這兩個(gè)結(jié)構(gòu)體主要是分別定義了cache manager和cache loader兩個(gè)進(jìn)程的不同行為。下面我們來(lái)看一下ngx_cache_manager_process_cycle()方法是如何調(diào)用這兩個(gè)方法的:

static void ngx_cache_manager_process_cycle(ngx_cycle_t *cycle, void *data) {
  ngx_cache_manager_ctx_t *ctx = data;

  void     *ident[4];
  ngx_event_t  ev;

  ngx_process = NGX_PROCESS_HELPER;

  // 當(dāng)前進(jìn)程主要是用于處理cache manager和cache loader工作的,因而其不需要進(jìn)行socket的監(jiān)聽(tīng),因而這里需要將其關(guān)閉
  ngx_close_listening_sockets(cycle);

  /* Set a moderate number of connections for a helper process. */
  cycle->connection_n = 512;

  // 對(duì)當(dāng)前的進(jìn)程進(jìn)行初始化,主要是設(shè)置一些參數(shù)屬性,并且在最后為當(dāng)前進(jìn)行設(shè)置監(jiān)聽(tīng)channel[1]句柄的事件,從而接收master進(jìn)程的消息
  ngx_worker_process_init(cycle, -1);

  ngx_memzero(&ev, sizeof(ngx_event_t));
  // 對(duì)于cache manager,這里的handler指向的是ngx_cache_manager_process_handler()方法,
  // 對(duì)于cache loader,這里的handler指向的是ngx_cache_loader_process_handler()方法
  ev.handler = ctx->handler;
  ev.data = ident;
  ev.log = cycle->log;
  ident[3] = (void *) -1;

  // cache模塊不需要使用共享鎖
  ngx_use_accept_mutex = 0;

  ngx_setproctitle(ctx->name);

  // 把當(dāng)前事件添加到事件隊(duì)列中,事件的延遲時(shí)間為ctx->delay,對(duì)于cache manager,該值為0,
  // 而對(duì)于cache loader,該值為60s。
  // 需要注意的是,在當(dāng)前事件的處理方法中,ngx_cache_manager_process_handler()如果處理完了當(dāng)前事件,
  // 會(huì)將當(dāng)前事件再次添加到事件隊(duì)列中,從而實(shí)現(xiàn)定時(shí)處理的功能;而對(duì)于
  // ngx_cache_loader_process_handler()方法,其處理完一次之后,并不會(huì)將當(dāng)前事件
  // 再次添加到事件隊(duì)列中,因而相當(dāng)于當(dāng)前事件只會(huì)執(zhí)行一次,然后cache loader進(jìn)程就會(huì)退出
  ngx_add_timer(&ev, ctx->delay);

  for ( ;; ) {

    // 如果master將當(dāng)前進(jìn)程標(biāo)記為terminate或者quit狀態(tài),則退出進(jìn)程
    if (ngx_terminate || ngx_quit) {
      ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
      exit(0);
    }

    // 如果master進(jìn)程發(fā)出了reopen消息,則重新打開(kāi)所有的緩存文件
    if (ngx_reopen) {
      ngx_reopen = 0;
      ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reopening logs");
      ngx_reopen_files(cycle, -1);
    }

    // 執(zhí)行事件隊(duì)列中的事件
    ngx_process_events_and_timers(cycle);
  }
}

上面的代碼中,首先創(chuàng)建了一個(gè)事件對(duì)象,ev.handler = ctx->handler;指定了該事件所需要處理的邏輯,也即上面兩個(gè)結(jié)構(gòu)體中的第一個(gè)參數(shù)所對(duì)應(yīng)的方法;然后將該事件添加到事件隊(duì)列中,即ngx_add_timer(&ev, ctx->delay);,需要注意的是,這里的第二個(gè)參數(shù)就是上面兩個(gè)結(jié)構(gòu)體中所指定的第三個(gè)參數(shù),也就是說(shuō)這里是以事件的延遲時(shí)間的方式來(lái)控制hander()方法的執(zhí)行時(shí)間的;最后,在一個(gè)無(wú)限for循環(huán)中,通過(guò)ngx_process_events_and_timers()方法來(lái)不斷檢查事件隊(duì)列的事件,并且處理事件。

3.3 cache manager進(jìn)程處理邏輯

對(duì)于cache manager處理的流程,通過(guò)上面的講解可以看出,其是在其所定義的cache manager結(jié)構(gòu)體中的ngx_cache_manager_process_handler()方法中進(jìn)行的。如下是該方法的源碼:

static void ngx_cache_manager_process_handler(ngx_event_t *ev) {
  ngx_uint_t  i;
  ngx_msec_t  next, n;
  ngx_path_t **path;

  next = 60 * 60 * 1000;

  path = ngx_cycle->paths.elts;
  for (i = 0; i < ngx_cycle->paths.nelts; i++) {

    // 這里的manager方法指向的是ngx_http_file_cache_manager()方法
    if (path[i]->manager) {
      n = path[i]->manager(path[i]->data);

      next = (n <= next) ? n : next;

      ngx_time_update();
    }
  }

  if (next == 0) {
    next = 1;
  }

  // 一次處理結(jié)束之后還會(huì)將當(dāng)前事件再次添加到事件隊(duì)列中而進(jìn)行下一次的處理
  ngx_add_timer(ev, next);
}

這里首先會(huì)獲取所有的路徑定義,然后檢查其manager()方法是否為空,如果不會(huì)空,則調(diào)用該方法。這里的manager()方法所指向的實(shí)際方法就是在前面3.1節(jié)中對(duì)proxy_cache_path指令進(jìn)行解析中進(jìn)行定義的,也即cache->path->manager = ngx_http_file_cache_manager;,也就是說(shuō)該方法是管理cache的主要方法。在調(diào)用完了管理方法之后,接下來(lái)會(huì)繼續(xù)將當(dāng)前的事件添加到事件隊(duì)列中,以進(jìn)行下一次cache管理循環(huán)。如下是ngx_http_file_cache_manager()方法的源碼:

static ngx_msec_t ngx_http_file_cache_manager(void *data) {
  // 這里的ngx_http_file_cache_t結(jié)構(gòu)體是解析proxy_cache_path配置項(xiàng)得到的
  ngx_http_file_cache_t *cache = data;

  off_t    size;
  time_t   wait;
  ngx_msec_t elapsed, next;
  ngx_uint_t count, watermark;

  cache->last = ngx_current_msec;
  cache->files = 0;

  // 這里的ngx_http_file_cache_expire()方法在一個(gè)無(wú)限循環(huán)中,不斷檢查緩存隊(duì)列尾部是否有過(guò)期的
  // 共享內(nèi)存,如果存在,則將其以及其所對(duì)應(yīng)的文件進(jìn)行刪除
  next = (ngx_msec_t) ngx_http_file_cache_expire(cache) * 1000;

  // next是ngx_http_file_cache_expire()方法的返回值,該方法只有在兩種情況下才會(huì)返回0:
  // 1. 當(dāng)刪除的文件個(gè)數(shù)超過(guò)了manager_files指定的文件個(gè)數(shù)時(shí);
  // 2. 當(dāng)刪除各個(gè)文件的總耗時(shí)超過(guò)了manager_threshold所指定的總時(shí)長(zhǎng)時(shí);
  // 如果next為0,則說(shuō)明完成了一個(gè)批次的緩存清理工作,此時(shí)是需要休眠一段時(shí)間然后再進(jìn)行下一次的清理工作,
  // 這個(gè)休眠的時(shí)長(zhǎng)就是manager_sleep所指定的值。也就是說(shuō)這里的next的值實(shí)際上就是下一次
  // 執(zhí)行緩存清理工作的等待時(shí)長(zhǎng)
  if (next == 0) {
    next = cache->manager_sleep;
    goto done;
  }

  for ( ;; ) {
    ngx_shmtx_lock(&cache->shpool->mutex);

    // 這里的size指的是當(dāng)前緩存所使用的總大小
    // count指定了當(dāng)前緩存中的文件個(gè)數(shù)
    // watermark則表示水位,其為總共能夠存儲(chǔ)的文件個(gè)數(shù)的7/8
    size = cache->sh->size;
    count = cache->sh->count;
    watermark = cache->sh->watermark;

    ngx_shmtx_unlock(&cache->shpool->mutex);

    ngx_log_debug3(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
            "http file cache size: %O c:%ui w:%i",
            size, count, (ngx_int_t) watermark);

    // 如果當(dāng)前的緩存所使用的內(nèi)存大小小于能夠使用的最大大小并且緩存文件個(gè)數(shù)小于水位,
    // 說(shuō)明還可以繼續(xù)存儲(chǔ)緩存文件,則跳出循環(huán)
    if (size < cache->max_size && count < watermark) {
      break;
    }

    // 走到這里說(shuō)明共享內(nèi)存可用資源不足
    // 這里主要是強(qiáng)制刪除當(dāng)前隊(duì)列中未被引用的文件,無(wú)論其是否過(guò)期
    wait = ngx_http_file_cache_forced_expire(cache);

    // 計(jì)算下次執(zhí)行的時(shí)間
    if (wait > 0) {
      next = (ngx_msec_t) wait * 1000;
      break;
    }

    // 如果當(dāng)前nginx已經(jīng)退出或者終止,則跳出循環(huán)
    if (ngx_quit || ngx_terminate) {
      break;
    }

    // 如果當(dāng)前刪除的文件個(gè)數(shù)超過(guò)了manager_files所指定的個(gè)數(shù),則跳出循環(huán),
    // 并且指定距離下次清理工作所需要休眠的時(shí)間
    if (++cache->files >= cache->manager_files) {
      next = cache->manager_sleep;
      break;
    }

    ngx_time_update();

    elapsed = ngx_abs((ngx_msec_int_t) (ngx_current_msec - cache->last));

    // 如果當(dāng)前刪除動(dòng)作的耗時(shí)超過(guò)了manager_threshold所指定的時(shí)長(zhǎng),則跳出循環(huán),
    // 并且指定距離下次清理工作所需要休眠的時(shí)間
    if (elapsed >= cache->manager_threshold) {
      next = cache->manager_sleep;
      break;
    }
  }

done:

  elapsed = ngx_abs((ngx_msec_int_t) (ngx_current_msec - cache->last));

  ngx_log_debug3(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
          "http file cache manager: %ui e:%M n:%M",
          cache->files, elapsed, next);

  return next;
}

在ngx_http_file_cache_manager()方法中,首先會(huì)進(jìn)入ngx_http_file_cache_expire()方法,該方法的主要作用是檢查當(dāng)前共享內(nèi)存隊(duì)列尾部的元素是否過(guò)期,如果過(guò)期,則根據(jù)其引用次數(shù)和是否正在被刪除而判斷是否需要將該元素以及該元素對(duì)應(yīng)的磁盤(pán)文件進(jìn)行刪除。在進(jìn)行這個(gè)檢查之后,然后會(huì)進(jìn)入一個(gè)無(wú)限for循環(huán),這里循環(huán)的主要目的是檢查當(dāng)前的共享內(nèi)存是否資源比較緊張,也即是否所使用的內(nèi)存超過(guò)了max_size定義的最大內(nèi)存,或者是當(dāng)前所緩存的文件總數(shù)超過(guò)了總文件數(shù)的7/8。如果這兩個(gè)條件有一個(gè)達(dá)到了,就會(huì)嘗試進(jìn)行強(qiáng)制清除緩存文件,所謂的強(qiáng)制清除就是刪除當(dāng)前共享內(nèi)存中所有被引用數(shù)為0的元素及其對(duì)應(yīng)的磁盤(pán)文件。這里我們首先閱讀ngx_http_file_cache_expire()方法:

static time_t ngx_http_file_cache_expire(ngx_http_file_cache_t *cache) {
  u_char           *name, *p;
  size_t            len;
  time_t            now, wait;
  ngx_path_t         *path;
  ngx_msec_t          elapsed;
  ngx_queue_t         *q;
  ngx_http_file_cache_node_t *fcn;
  u_char            key[2 * NGX_HTTP_CACHE_KEY_LEN];

  ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
          "http file cache expire");

  path = cache->path;
  len = path->name.len + 1 + path->len + 2 * NGX_HTTP_CACHE_KEY_LEN;

  name = ngx_alloc(len + 1, ngx_cycle->log);
  if (name == NULL) {
    return 10;
  }

  ngx_memcpy(name, path->name.data, path->name.len);

  now = ngx_time();

  ngx_shmtx_lock(&cache->shpool->mutex);

  for ( ;; ) {

    // 如果當(dāng)前nginx已經(jīng)退出了,或者終止了,則跳出當(dāng)前循環(huán)
    if (ngx_quit || ngx_terminate) {
      wait = 1;
      break;
    }

    // 如果當(dāng)前的共享內(nèi)存隊(duì)列為空的,則跳出當(dāng)前循環(huán)
    if (ngx_queue_empty(&cache->sh->queue)) {
      wait = 10;
      break;
    }

    // 獲取隊(duì)列的最后一個(gè)元素
    q = ngx_queue_last(&cache->sh->queue);

    // 獲取隊(duì)列的節(jié)點(diǎn)
    fcn = ngx_queue_data(q, ngx_http_file_cache_node_t, queue);

    // 計(jì)算節(jié)點(diǎn)的過(guò)期時(shí)間距離當(dāng)前時(shí)間的時(shí)長(zhǎng)
    wait = fcn->expire - now;

    // 如果當(dāng)前節(jié)點(diǎn)沒(méi)有過(guò)期,則退出當(dāng)前循環(huán)
    if (wait > 0) {
      wait = wait > 10 ? 10 : wait;
      break;
    }

    ngx_log_debug6(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
            "http file cache expire: #%d %d %02xd%02xd%02xd%02xd",
            fcn->count, fcn->exists,
            fcn->key[0], fcn->key[1], fcn->key[2], fcn->key[3]);

    // 這里的count表示當(dāng)前的節(jié)點(diǎn)被引用的次數(shù),如果其引用次數(shù)為0,則直接刪除該節(jié)點(diǎn)
    if (fcn->count == 0) {
      // 這里的主要?jiǎng)幼魇菍?dāng)前的節(jié)點(diǎn)從隊(duì)列中移除,并且刪除該節(jié)點(diǎn)對(duì)應(yīng)的文件
      ngx_http_file_cache_delete(cache, q, name);
      goto next;
    }

    // 如果當(dāng)前節(jié)點(diǎn)正在被刪除,那么當(dāng)前進(jìn)程就可以不用對(duì)其進(jìn)行處理
    if (fcn->deleting) {
      wait = 1;
      break;
    }

    // 走到這里,說(shuō)明當(dāng)前節(jié)點(diǎn)已經(jīng)過(guò)期了,但是引用數(shù)大于0,并且沒(méi)有進(jìn)程正在刪除該節(jié)點(diǎn)
    // 這里計(jì)算的是該節(jié)點(diǎn)進(jìn)行hex計(jì)算后文件的名稱
    p = ngx_hex_dump(key, (u_char *) &fcn->node.key, sizeof(ngx_rbtree_key_t));
    len = NGX_HTTP_CACHE_KEY_LEN - sizeof(ngx_rbtree_key_t);
    (void) ngx_hex_dump(p, fcn->key, len);

    // 由于當(dāng)前節(jié)點(diǎn)在時(shí)間上已經(jīng)過(guò)期了,但是有請(qǐng)求正在引用該節(jié)點(diǎn),并且沒(méi)有進(jìn)程正在刪除該節(jié)點(diǎn),
    // 說(shuō)明該節(jié)點(diǎn)應(yīng)該被保留,因而這里嘗試將該節(jié)點(diǎn)從隊(duì)列尾部刪除,并且為其重新計(jì)算下次的過(guò)期時(shí)間,
    // 然后將其插入到隊(duì)列頭部
    ngx_queue_remove(q);
    fcn->expire = ngx_time() + cache->inactive;
    ngx_queue_insert_head(&cache->sh->queue, &fcn->queue);

    ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
           "ignore long locked inactive cache entry %*s, count:%d",
           (size_t) 2 * NGX_HTTP_CACHE_KEY_LEN, key, fcn->count);

next:  // 這里是隊(duì)列中的最后一個(gè)節(jié)點(diǎn)被刪除,并且對(duì)應(yīng)的文件也被刪除之后才會(huì)執(zhí)行的邏輯

    // 這里的cache->files記錄了當(dāng)前已經(jīng)處理的節(jié)點(diǎn)數(shù),manager_files的含義在于,
    // 在進(jìn)行LRU算法強(qiáng)制清除文件時(shí),最多會(huì)清除該參數(shù)所指定的文件個(gè)數(shù),默認(rèn)為100。
    // 因而這里如果cache->files如果大于等于manager_files,則跳出循環(huán)
    if (++cache->files >= cache->manager_files) {
      wait = 0;
      break;
    }

    // 更新當(dāng)前nginx緩存的時(shí)間
    ngx_time_update();

    // elapsed等于當(dāng)前刪除動(dòng)作的總耗時(shí)
    elapsed = ngx_abs((ngx_msec_int_t) (ngx_current_msec - cache->last));

    // 如果總耗時(shí)超過(guò)了manager_threshold所指定的值,則跳出當(dāng)前循環(huán)
    if (elapsed >= cache->manager_threshold) {
      wait = 0;
      break;
    }
  }

  // 釋放當(dāng)前的鎖
  ngx_shmtx_unlock(&cache->shpool->mutex);

  ngx_free(name);

  return wait;
}

可以看到,這里的主要處理邏輯是首先會(huì)火嘴隊(duì)列尾部的元素,根據(jù)LRU算法,隊(duì)列尾部的元素是最有可能過(guò)期的元素,因而只需要檢查該元素即可。然后檢查該元素是否過(guò)期,如果沒(méi)有過(guò)期,則退出當(dāng)前方法,否則檢查當(dāng)前元素是否引用數(shù)為0,也就是說(shuō)如果當(dāng)前元素已經(jīng)過(guò)期,并且引用數(shù)為0,則直接刪除該元素及其對(duì)應(yīng)的磁盤(pán)文件。如果當(dāng)前元素引用數(shù)不為0,則會(huì)檢查其是否正在被刪除,需要注意的是,如果一個(gè)元素正在被刪除,那么刪除進(jìn)程是會(huì)將其引用數(shù)置為1的,以防止其他的進(jìn)程也進(jìn)行刪除操作。如果其正在被刪除,則當(dāng)前進(jìn)程不會(huì)處理該元素,如果沒(méi)有被刪除,則當(dāng)前進(jìn)程會(huì)嘗試將該元素從隊(duì)列尾部移動(dòng)到隊(duì)列頭部,這么做的主要原因在于,雖然元素已經(jīng)過(guò)期,但是其引用數(shù)不為0,并且沒(méi)有進(jìn)程正在刪除該元素,那么說(shuō)明該元素還是一個(gè)活躍元素,因而需要將其移動(dòng)到隊(duì)列頭部。

下面我們來(lái)看一下,當(dāng)資源比較緊張時(shí),cache manager是如何強(qiáng)制清除元素的,如下是ngx_http_file_cache_forced_expire()方法的源碼:

static time_t ngx_http_file_cache_forced_expire(ngx_http_file_cache_t *cache) {
  u_char           *name;
  size_t            len;
  time_t            wait;
  ngx_uint_t          tries;
  ngx_path_t         *path;
  ngx_queue_t         *q;
  ngx_http_file_cache_node_t *fcn;

  ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
          "http file cache forced expire");

  path = cache->path;
  len = path->name.len + 1 + path->len + 2 * NGX_HTTP_CACHE_KEY_LEN;

  name = ngx_alloc(len + 1, ngx_cycle->log);
  if (name == NULL) {
    return 10;
  }

  ngx_memcpy(name, path->name.data, path->name.len);

  wait = 10;
  tries = 20;

  ngx_shmtx_lock(&cache->shpool->mutex);

  // 不斷遍歷隊(duì)列中的每個(gè)節(jié)點(diǎn)
  for (q = ngx_queue_last(&cache->sh->queue);
     q != ngx_queue_sentinel(&cache->sh->queue);
     q = ngx_queue_prev(q))
  {
    // 獲取當(dāng)前節(jié)點(diǎn)的數(shù)據(jù)
    fcn = ngx_queue_data(q, ngx_http_file_cache_node_t, queue);

    ngx_log_debug6(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
         "http file cache forced expire: #%d %d %02xd%02xd%02xd%02xd",
         fcn->count, fcn->exists,
         fcn->key[0], fcn->key[1], fcn->key[2], fcn->key[3]);

    // 如果當(dāng)前節(jié)點(diǎn)的引用數(shù)為0,則直接刪除該節(jié)點(diǎn)
    if (fcn->count == 0) {
      ngx_http_file_cache_delete(cache, q, name);
      wait = 0;

    } else {
      // 進(jìn)行下一個(gè)節(jié)點(diǎn)的嘗試,如果有連續(xù)的20個(gè)節(jié)點(diǎn)的引用數(shù)都大于0,則會(huì)跳出當(dāng)前循環(huán)
      if (--tries) {
        continue;
      }

      wait = 1;
    }

    break;
  }

  ngx_shmtx_unlock(&cache->shpool->mutex);

  ngx_free(name);

  return wait;
}

可以看到,這里的處理邏輯比較簡(jiǎn)單,主要是從隊(duì)列尾部開(kāi)始往前依次檢查隊(duì)列中的元素的引用次數(shù)是否為0,如果為0,則直接刪除,然后檢查下一個(gè)元素。如果不為0,則檢查下一個(gè)元素,如此往復(fù)。這里需要注意的是,如果檢查總共有20次元素正在被引用過(guò)程中,則跳出當(dāng)前循環(huán)。

3.4 cache loader進(jìn)程處理邏輯

前面已經(jīng)講到,cache loader的主要處理流程在ngx_cache_loader_process_handler()方法中,如下是該方法的主要處理邏輯:

static void ngx_cache_loader_process_handler(ngx_event_t *ev)
{
  ngx_uint_t   i;
  ngx_path_t  **path;
  ngx_cycle_t  *cycle;

  cycle = (ngx_cycle_t *) ngx_cycle;

  path = cycle->paths.elts;
  for (i = 0; i < cycle->paths.nelts; i++) {

    if (ngx_terminate || ngx_quit) {
      break;
    }

    // 這里的loader方法指向的是ngx_http_file_cache_loader()方法
    if (path[i]->loader) {
      path[i]->loader(path[i]->data);
      ngx_time_update();
    }
  }

  // 加載完成后退出當(dāng)前流程
  exit(0);
}

這里cache loader與cache manager的處理主流程是非常相似的,主要是通過(guò)調(diào)用各個(gè)路徑的loader()方法進(jìn)行數(shù)據(jù)加載的,而loader()方法的具體實(shí)現(xiàn)方法也是在proxy_cache_path配置項(xiàng)解析的時(shí)候定義的,具體的定義如下(在3.1節(jié)最后一部分):

cache->path->loader = ngx_http_file_cache_loader;

這里我們繼續(xù)閱讀ngx_http_file_cache_loader()方法的源碼:

static void ngx_http_file_cache_loader(void *data) {
  ngx_http_file_cache_t *cache = data;

  ngx_tree_ctx_t tree;

  // 如果已經(jīng)加載完成或者正在加載,則直接返回
  if (!cache->sh->cold || cache->sh->loading) {
    return;
  }

  // 嘗試加鎖
  if (!ngx_atomic_cmp_set(&cache->sh->loading, 0, ngx_pid)) {
    return;
  }

  ngx_log_debug0(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
          "http file cache loader");

  // 這里的tree就是加載的一個(gè)主要流程對(duì)象,加載的過(guò)程是通過(guò)遞歸的方式進(jìn)行的
  tree.init_handler = NULL;
  // 封裝了加載單個(gè)文件的操作
  tree.file_handler = ngx_http_file_cache_manage_file;
  // 在加載一個(gè)目錄之前的操作,這里主要是檢查當(dāng)前目錄有沒(méi)有操作權(quán)限
  tree.pre_tree_handler = ngx_http_file_cache_manage_directory;
  // 在加載一個(gè)目錄之后的操作,這里實(shí)際上是一個(gè)空方法
  tree.post_tree_handler = ngx_http_file_cache_noop;
 // 這里主要是處理特殊文件,即既不是文件也不是文件夾的文件,這里主要是刪除了該文件
  tree.spec_handler = ngx_http_file_cache_delete_file;
  tree.data = cache;
  tree.alloc = 0;
  tree.log = ngx_cycle->log;

  cache->last = ngx_current_msec;
  cache->files = 0;

  // 開(kāi)始通過(guò)遞歸的方式遍歷指定目錄下的所有文件,然后按照上面定義的方法對(duì)其進(jìn)行處理,也即加載到共享內(nèi)存中
  if (ngx_walk_tree(&tree, &cache->path->name) == NGX_ABORT) {
    cache->sh->loading = 0;
    return;
  }

  // 標(biāo)記加載狀態(tài)
  cache->sh->cold = 0;
  cache->sh->loading = 0;

  ngx_log_error(NGX_LOG_NOTICE, ngx_cycle->log, 0,
         "http file cache: %V %.3fM, bsize: %uz",
         &cache->path->name,
         ((double) cache->sh->size * cache->bsize) / (1024 * 1024),
         cache->bsize);
}

在加載過(guò)程中,首先將目標(biāo)加載目錄封裝到一個(gè)ngx_tree_ctx_t結(jié)構(gòu)體中,并且為其指定加載文件所使用的方法。最終的加載邏輯主要是在ngx_walk_tree()方法中進(jìn)行的,而整個(gè)加載過(guò)程也是通過(guò)遞歸來(lái)實(shí)現(xiàn)的。如下是ngx_walk_tree()方法的實(shí)現(xiàn)原理:

ngx_int_t ngx_walk_tree(ngx_tree_ctx_t *ctx, ngx_str_t *tree) {
  void    *data, *prev;
  u_char   *p, *name;
  size_t   len;
  ngx_int_t  rc;
  ngx_err_t  err;
  ngx_str_t  file, buf;
  ngx_dir_t  dir;

  ngx_str_null(&buf);

  ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
          "walk tree \"%V\"", tree);

  // 打開(kāi)目標(biāo)目錄
  if (ngx_open_dir(tree, &dir) == NGX_ERROR) {
    ngx_log_error(NGX_LOG_CRIT, ctx->log, ngx_errno,
           ngx_open_dir_n " \"%s\" failed", tree->data);
    return NGX_ERROR;
  }

  prev = ctx->data;

  // 這里傳入的alloc是0,因而不會(huì)進(jìn)入當(dāng)前分支
  if (ctx->alloc) {
    data = ngx_alloc(ctx->alloc, ctx->log);
    if (data == NULL) {
      goto failed;
    }

    if (ctx->init_handler(data, prev) == NGX_ABORT) {
      goto failed;
    }

    ctx->data = data;

  } else {
    data = NULL;
  }

  for ( ;; ) {

    ngx_set_errno(0);

    // 讀取當(dāng)前子目錄中的內(nèi)容
    if (ngx_read_dir(&dir) == NGX_ERROR) {
      err = ngx_errno;

      if (err == NGX_ENOMOREFILES) {
        rc = NGX_OK;

      } else {
        ngx_log_error(NGX_LOG_CRIT, ctx->log, err,
               ngx_read_dir_n " \"%s\" failed", tree->data);
        rc = NGX_ERROR;
      }

      goto done;
    }

    len = ngx_de_namelen(&dir);
    name = ngx_de_name(&dir);

    ngx_log_debug2(NGX_LOG_DEBUG_CORE, ctx->log, 0,
           "tree name %uz:\"%s\"", len, name);

    // 如果當(dāng)前讀取到的是.,則表示其為當(dāng)前目錄,跳過(guò)該目錄
    if (len == 1 && name[0] == '.') {
      continue;
    }

    // 如果當(dāng)前讀取到的是..,則表示其為返回上一級(jí)目錄的標(biāo)識(shí),跳過(guò)該目錄
    if (len == 2 && name[0] == '.' && name[1] == '.') {
      continue;
    }

    file.len = tree->len + 1 + len;

    // 更新可用的緩存大小
    if (file.len + NGX_DIR_MASK_LEN > buf.len) {

      if (buf.len) {
        ngx_free(buf.data);
      }

      buf.len = tree->len + 1 + len + NGX_DIR_MASK_LEN;

      buf.data = ngx_alloc(buf.len + 1, ctx->log);
      if (buf.data == NULL) {
        goto failed;
      }
    }

    p = ngx_cpymem(buf.data, tree->data, tree->len);
    *p++ = '/';
    ngx_memcpy(p, name, len + 1);

    file.data = buf.data;

    ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
            "tree path \"%s\"", file.data);

    if (!dir.valid_info) {
      if (ngx_de_info(file.data, &dir) == NGX_FILE_ERROR) {
        ngx_log_error(NGX_LOG_CRIT, ctx->log, ngx_errno,
               ngx_de_info_n " \"%s\" failed", file.data);
        continue;
      }
    }

    // 如果當(dāng)前讀取到的是一個(gè)文件,則調(diào)用ctx->file_handler()加載該文件的內(nèi)容
    if (ngx_de_is_file(&dir)) {

      ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
              "tree file \"%s\"", file.data);

      // 設(shè)置文件的相關(guān)屬性
      ctx->size = ngx_de_size(&dir);
      ctx->fs_size = ngx_de_fs_size(&dir);
      ctx->access = ngx_de_access(&dir);
      ctx->mtime = ngx_de_mtime(&dir);

      if (ctx->file_handler(ctx, &file) == NGX_ABORT) {
        goto failed;
      }

     // 如果當(dāng)前讀取到的是一個(gè)目錄,則首先調(diào)用設(shè)置的pre_tree_handler()方法,然后調(diào)用
     // ngx_walk_tree()方法,遞歸的讀取子目錄,最后調(diào)用設(shè)置的post_tree_handler()方法
    } else if (ngx_de_is_dir(&dir)) {

      ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
              "tree enter dir \"%s\"", file.data);

      ctx->access = ngx_de_access(&dir);
      ctx->mtime = ngx_de_mtime(&dir);

      // 應(yīng)用讀取目錄的前置邏輯
      rc = ctx->pre_tree_handler(ctx, &file);

      if (rc == NGX_ABORT) {
        goto failed;
      }

      if (rc == NGX_DECLINED) {
        ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
                "tree skip dir \"%s\"", file.data);
        continue;
      }

      // 遞歸的讀取當(dāng)前目錄
      if (ngx_walk_tree(ctx, &file) == NGX_ABORT) {
        goto failed;
      }

      ctx->access = ngx_de_access(&dir);
      ctx->mtime = ngx_de_mtime(&dir);

      // 應(yīng)用讀取目錄的后置邏輯
      if (ctx->post_tree_handler(ctx, &file) == NGX_ABORT) {
        goto failed;
      }

    } else {

      ngx_log_debug1(NGX_LOG_DEBUG_CORE, ctx->log, 0,
              "tree special \"%s\"", file.data);

      if (ctx->spec_handler(ctx, &file) == NGX_ABORT) {
        goto failed;
      }
    }
  }

failed:

  rc = NGX_ABORT;

done:

  if (buf.len) {
    ngx_free(buf.data);
  }

  if (data) {
    ngx_free(data);
    ctx->data = prev;
  }

  if (ngx_close_dir(&dir) == NGX_ERROR) {
    ngx_log_error(NGX_LOG_CRIT, ctx->log, ngx_errno,
           ngx_close_dir_n " \"%s\" failed", tree->data);
  }

  return rc;
}

從上面的處理流程可以看出,真正的加載文件的邏輯在ngx_http_file_cache_manage_file()方法中,如下是該方法的源碼:

static ngx_int_t ngx_http_file_cache_manage_file(ngx_tree_ctx_t *ctx, ngx_str_t *path) {
  ngx_msec_t       elapsed;
  ngx_http_file_cache_t *cache;

  cache = ctx->data;

  // 將文件添加到共享內(nèi)存中
  if (ngx_http_file_cache_add_file(ctx, path) != NGX_OK) {
    (void) ngx_http_file_cache_delete_file(ctx, path);
  }

  // 如果加載的文件個(gè)數(shù)超過(guò)了loader_files指定的個(gè)數(shù),則休眠一段時(shí)間
  if (++cache->files >= cache->loader_files) {
    ngx_http_file_cache_loader_sleep(cache);

  } else {
    // 更新當(dāng)前緩存的時(shí)間
    ngx_time_update();

    // 計(jì)算當(dāng)前加載炒作的耗時(shí)
    elapsed = ngx_abs((ngx_msec_int_t) (ngx_current_msec - cache->last));

    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ngx_cycle->log, 0,
            "http file cache loader time elapsed: %M", elapsed);

    // 如果加載操作耗時(shí)超過(guò)了loader_threshold所指定的時(shí)間,則休眠指定的時(shí)間
    if (elapsed >= cache->loader_threshold) {
      ngx_http_file_cache_loader_sleep(cache);
    }
  }

  return (ngx_quit || ngx_terminate) ? NGX_ABORT : NGX_OK;
}

這里的加載邏輯整體而言比較簡(jiǎn)單,主要過(guò)程就是將該文件加載到共享內(nèi)存中,并且會(huì)判斷加載的文件數(shù)量是否超限,如果超限了,則會(huì)休眠指定的時(shí)長(zhǎng);另外,也會(huì)判斷加載文件的總耗時(shí)是否超過(guò)了指定時(shí)長(zhǎng),如果超過(guò)了,也會(huì)休眠指定的時(shí)長(zhǎng)。

4. 小結(jié)

本文首先講解了nginx共享內(nèi)存的使用方式以及各個(gè)參數(shù)的具體含義,然后對(duì)共享內(nèi)存的實(shí)現(xiàn)原理進(jìn)行了講解,最后著重講解了共享內(nèi)存的初始化、cache manager和cache loader的工作原理。

以上就是本文的全部?jī)?nèi)容,希望對(duì)大家的學(xué)習(xí)有所幫助,也希望大家多多支持腳本之家。

標(biāo)簽:雅安 長(zhǎng)治 中衛(wèi) 臺(tái)灣 興安盟 清遠(yuǎn) 大慶 安陽(yáng)

巨人網(wǎng)絡(luò)通訊聲明:本文標(biāo)題《nginx共享內(nèi)存機(jī)制詳解》,本文關(guān)鍵詞  nginx,共享,內(nèi)存,機(jī)制,詳解,;如發(fā)現(xiàn)本文內(nèi)容存在版權(quán)問(wèn)題,煩請(qǐng)?zhí)峁┫嚓P(guān)信息告之我們,我們將及時(shí)溝通與處理。本站內(nèi)容系統(tǒng)采集于網(wǎng)絡(luò),涉及言論、版權(quán)與本站無(wú)關(guān)。
  • 相關(guān)文章
  • 下面列出與本文章《nginx共享內(nèi)存機(jī)制詳解》相關(guān)的同類信息!
  • 本頁(yè)收集關(guān)于nginx共享內(nèi)存機(jī)制詳解的相關(guān)信息資訊供網(wǎng)民參考!
  • 推薦文章