redis学习笔记--redis过期机制学习

typedef struct redisDb {
      dict *dict;                 /* The keyspace for this DB */
      dict *expires;              /* Timeout of keys with a timeout set */
      dict *blocking_keys;        /* Keys with clients waiting for data (BLPOP)*/
      dict *ready_keys;           /* Blocked keys that received a PUSH */
      dict *watched_keys;         /* WATCHED keys for MULTI/EXEC CAS */
      int id;                     /* Database ID */
      long long avg_ttl;          /* Average TTL, just for stats */
      unsigned long expires_cursor; /* Cursor of the active expire cycle. */
      list *defrag_later;         /* List of key names to attempt to defrag one by one, gradually. */
  } redisDb;

/* EXPIRE key seconds */                                                       
  void expireCommand(client *c) {                                                
      expireGenericCommand(c,mstime(),UNIT_SECONDS);                             
  }                                                                                                             
                                                                                 
  /* EXPIREAT key time */                                                        
  void expireatCommand(client *c) {                                              
      expireGenericCommand(c,0,UNIT_SECONDS);                                    
  }                                                                              
                                                                                 
  /* PEXPIRE key milliseconds */                                                 
  void pexpireCommand(client *c) {                                               
      expireGenericCommand(c,mstime(),UNIT_MILLISECONDS);                        
  }                                                                              
                                                                                 
  /* PEXPIREAT key ms_time */                                                    
  void pexpireatCommand(client *c) {                                             
      expireGenericCommand(c,0,UNIT_MILLISECONDS);                               
  }

if(key不存在):
    return -2
if(key没设置过期时间):
    return -1

ttl = 计算过期时间()
return 过期时间

  #define ACTIVE_EXPIRE_CYCLE_KEYS_PER_LOOP 20 /* 默认每个数据库检查的键数量. */
  #define ACTIVE_EXPIRE_CYCLE_FAST_DURATION 1000 /* “快周期”的周期时间，单位微秒. */                                            
  #define ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 25 /* "慢周期“做多可占用的cpu资源，% */
  #define ACTIVE_EXPIRE_CYCLE_ACCEPTABLE_STALE 10 /*可容忍的过期键所占内存百分比 */

      effort = server.active_expire_effort-1, /* Rescale from 0 to 9. */
      config_keys_per_loop = ACTIVE_EXPIRE_CYCLE_KEYS_PER_LOOP +
                             ACTIVE_EXPIRE_CYCLE_KEYS_PER_LOOP/4*effort,
      config_cycle_fast_duration = ACTIVE_EXPIRE_CYCLE_FAST_DURATION +
                                   ACTIVE_EXPIRE_CYCLE_FAST_DURATION/4*effort,
      config_cycle_slow_time_perc = ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC +
                                    2*effort,
      config_cycle_acceptable_stale = ACTIVE_EXPIRE_CYCLE_ACCEPTABLE_STALE-                                     
                                      effort;

      static unsigned int current_db = 0; /* 上个周期结束时执行到的db */
      static int timelimit_exit = 0;      /* 上一个周期是否因为超时而退出？ */                                
      static long long last_fast_cycle = 0; /* 上一个”快周期“的运行时间 */

//如果上次不是因为超时而结束，并且当前过期键数量小于可容忍的过期键数量，不处理
if(type == ACTIVE_EXPIRE_CYCLE_FAST):
    if(timelimit_exit && server.stat_expired_stale_perc < config_cycle_acceptable_stale) :
        return;
    
    //如果距离上次fast模式的运行时间小于两倍的fast模式的周期，不处理
    if(start < last_fast_cycle + (long long)config_cycle_fast_duration*2) :
        return;
    
    //以上检查全过，那么就可以开始fast模式，记录一下本次的运行时间
    last_fast_cycle = start


//如果服务器的db数量比默认的db检查数量小，以服务器的数量为准
//如果上次是超时退出，也会在检查一遍过期键数量
if(dbs_per_call > server.dbnum || timelimit_exit) :
    dbs_per_call = server.dbnum;

//开始处理每个db中的过期键
for i in range(dbs_per_call):
    //获取当前的db，并将currentdb的索引加一
    redisDb = server.db[current_db]
    current_db += 1
    
    //如果当先过期键的数量大于可容忍的过期键数量，那么开始执行清理
    while((expired*100/sampled) > config_cycle_acceptable_stale):
        //该db没有过期键，不处理
        if((num = dictSize(db->expires)) == 0):
            break
            
        max_buckets = num*20; //最大的hash桶数量
        checked_buckets = 0; //当前检查的hash桶
        
        //采样数量小于每个db的默认检查键数量，当前检查的桶小于最大桶
        while(sampled < num && checked_buckets < max_buckets):
            //从当前db的过期游标开始检查过期键
            idx = db->expires_cursor
            idx &= db->expires->ht[table].sizemask
            dictEntry *de = db->expires->ht[table].table[idx]
            
            while(de):
                dictEntry *e = de
                de = de->next
                ttl = dictGetSignedIntegerVal(e)-now;
                //如果key过期，删除并计数+1
                if (activeExpireCycleTryExpire(db,e,now)) expired+=1;
                //记录采样数据
                if (ttl > 0):
                    ttl_sum += ttl;//为了统计平均ttl用的
                    ttl_samples+=1;
                samples += 1
            db->expires_cursor++;
        total_expired += expired
        total_sampled += sampled
        
        //超时则退出，并标记
        if(ustime()-start > timelimit):
            timelimit_exit = 1;
            server.stat_expired_time_cap_reached_count++;
            break