typedef struct redisDb {
  dict *dict;//存儲主鍵和值的映射
  dict *expires;//存儲主鍵和過期時間的映射
  dict *blocking_keys;
  dict *ready_keys;
  dict *watched_keys;
  int id;
} redisDb;

void propagateExpire(redisDb *db, robj *key) {
  robj *argv[2];
  //shared.del是在Redis服務器啟動之初就已經(jīng)初始化好的一個常用Redis對象，即DEL命令
  argv[0] = shared.del;
  argv[1] = key;
  incrRefCount(argv[0]);
  incrRefCount(argv[1]);
  //檢查Redis服務器是否開啟了AOF，如果開啟了就為失效主鍵記錄一條DEL日志
  if (server.aof_state != REDIS_AOF_OFF)
    feedAppendOnlyFile(server.delCommand,db->id,argv,2);
  //檢查Redis服務器是否擁有Slave，如果是就向所有Slave發(fā)送DEL失效主鍵的命令，這就是
  //上面expireIfNeeded函數(shù)中發(fā)現(xiàn)自己是Slave時無需主動刪除失效主鍵的原因了，因為它
  //只需聽從Master發(fā)送過來的命令就OK了
  if (listLength(server.slaves))
    replicationFeedSlaves(server.slaves,db->id,argv,2);
  decrRefCount(argv[0]);
  decrRefCount(argv[1]);
}

void activeExpireCycle(void) {
  //因為每次調(diào)用activeExpireCycle函數(shù)不會一次性檢查所有Redis數(shù)據(jù)庫，所以需要記錄下
  //每次函數(shù)調(diào)用處理的最后一個Redis數(shù)據(jù)庫的編號，這樣下次調(diào)用activeExpireCycle函數(shù)
  //還可以從這個數(shù)據(jù)庫開始繼續(xù)處理，這就是current_db被聲明為static的原因，而另外一
  //個變量timelimit_exit是為了記錄上一次調(diào)用activeExpireCycle函數(shù)的執(zhí)行時間是否達
  //到時間限制了，所以也需要聲明為static
  static unsigned int current_db = 0;
  static int timelimit_exit = 0;
  unsigned int j, iteration = 0;
  //每次調(diào)用activeExpireCycle函數(shù)處理的Redis數(shù)據(jù)庫個數(shù)為REDIS_DBCRON_DBS_PER_CALL
  unsigned int dbs_per_call = REDIS_DBCRON_DBS_PER_CALL;
  long long start = ustime(), timelimit;
  //如果當前Redis服務器中的數(shù)據(jù)庫個數(shù)小于REDIS_DBCRON_DBS_PER_CALL，則處理全部數(shù)據(jù)庫，
  //如果上一次調(diào)用activeExpireCycle函數(shù)的執(zhí)行時間達到了時間限制，說明失效主鍵較多，也
  //會選擇處理全部數(shù)據(jù)庫
  if (dbs_per_call > server.dbnum || timelimit_exit)
    dbs_per_call = server.dbnum;
  //執(zhí)行activeExpireCycle函數(shù)的最長時間（以微秒計），其中REDIS_EXPIRELOOKUPS_TIME_PERC
  //是單位時間內(nèi)能夠分配給activeExpireCycle函數(shù)執(zhí)行的CPU時間比例，默認值為25，server.hz
  //即為一秒內(nèi)activeExpireCycle的調(diào)用次數(shù)，所以這個計算公式更明白的寫法應該是這樣的，即
  (1000000 * (REDIS_EXPIRELOOKUPS_TIME_PERC / 100)) / server.hz
  timelimit = 1000000*REDIS_EXPIRELOOKUPS_TIME_PERC/server.hz/100;
  timelimit_exit = 0;
  if (timelimit <= 0) timelimit = 1;
  //遍歷處理每個Redis數(shù)據(jù)庫中的失效數(shù)據(jù)
  for (j = 0; j < dbs_per_call; j++) {
    int expired;
    redisDb *db = server.db+(current_db % server.dbnum);
    //此處立刻就將current_db加一，這樣可以保證即使這次無法在時間限制內(nèi)刪除完所有當前
    //數(shù)據(jù)庫中的失效主鍵，下一次調(diào)用activeExpireCycle一樣會從下一個數(shù)據(jù)庫開始處理，
    //從而保證每個數(shù)據(jù)庫都有被處理的機會
    current_db++;
    //開始處理當前數(shù)據(jù)庫中的失效主鍵
    do {
      unsigned long num, slots;
      long long now;
      //如果expires字典表大小為0，說明該數(shù)據(jù)庫中沒有設置失效時間的主鍵，直接檢查下
      //一數(shù)據(jù)庫
      if ((num = dictSize(db->expires)) == 0) break;
      slots = dictSlots(db->expires);
      now = mstime();
      //如果expires字典表不為空，但是其填充率不足1%，那么隨機選擇主鍵進行檢查的代價
      //會很高，所以這里直接檢查下一數(shù)據(jù)庫
      if (num && slots > DICT_HT_INITIAL_SIZE &&
        (num*100/slots < 1)) break;
      expired = 0;
      //如果expires字典表中的entry個數(shù)不足以達到抽樣個數(shù)，則選擇全部key作為抽樣樣本
      if (num > REDIS_EXPIRELOOKUPS_PER_CRON)
        num = REDIS_EXPIRELOOKUPS_PER_CRON;
      while (num--) {
        dictEntry *de;
        long long t;
        //隨機獲取一個設置了失效時間的主鍵，檢查其是否已經(jīng)失效
        if ((de = dictGetRandomKey(db->expires)) == NULL) break;
        t = dictGetSignedIntegerVal(de);
        if (now > t) {
          //發(fā)現(xiàn)該主鍵確實已經(jīng)失效，刪除該主鍵
          sds key = dictGetKey(de);
          robj *keyobj = createStringObject(key,sdslen(key));
          //同樣要在刪除前廣播該主鍵的失效信息
          propagateExpire(db,keyobj);
          dbDelete(db,keyobj);
          decrRefCount(keyobj);
          expired++;
          server.stat_expiredkeys++;
        }
      }
      //每進行一次抽樣刪除后對iteration加一，每16次抽樣刪除后檢查本次執(zhí)行時間是否
      //已經(jīng)達到時間限制，如果已達到時間限制，則記錄本次執(zhí)行達到時間限制并退出
      iteration++;
      if ((iteration & 0xf) == 0 &&
        (ustime()-start) > timelimit)
      {
        timelimit_exit = 1;
        return;
      }
    //如果失效的主鍵數(shù)占抽樣數(shù)的百分比大于25%，則繼續(xù)抽樣刪除過程
    } while (expired > REDIS_EXPIRELOOKUPS_PER_CRON/4);
  }
}