redis代码 数据超时实现

redis的超时处理
1） 当再次访问该数据时， 发现该数据已超时过期， 则删掉； 返回给调用者为空。（被动发现）
2） redis server起来之后， 会注册定时器事件(每毫秒触发1次超时)， 在该定时器处理函数中， 轮流各db；大致策略是从该db.expired dict中：
-----a. 尝试取20(ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)次随机key，判断是否有过期的，过期的处理掉。 如果该db中过期的不足5个(ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4)，则不再处理该db、转而处理下一个db。
-----b. 执行a 16的整数倍次。如果此时发现本次处理时间已太长（>25ms）， 则不再处理。否则继续a  16次。


typedef struct redisDb {
    dict *dict;                 /* The keyspace for this DB */
    dict *expires;              /* Timeout of keys with a timeout set */如果数据设置了超时，则dict和expires中都会放一份。
    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;
    long long avg_ttl;          /* Average TTL, just for stats */数据近似平均过期时间
} redisDb;

struct redisServer {
    /* General */
    char *configfile;           /* Absolute config file path, or NULL */
    int hz;                     /* serverCron() calls frequency in hertz */
    redisDb *db;
    dict *commands;             /* Command table */
    dict *orig_commands;        /* Command table before command renaming. */
    aeEventLoop *el;
    unsigned lruclock:22;       /* Clock incrementing every minute, for LRU */分钟级别的超时设置。
    unsigned lruclock_padding:10;
    int shutdown_asap;          /* SHUTDOWN needed ASAP */
    ....
};

#define REDIS_LRU_CLOCK_MAX ((1<<21)-1) /* Max value of obj->lru */
#define REDIS_LRU_CLOCK_RESOLUTION 10 /* LRU clock resolution in seconds */
typedef struct redisObject {
    unsigned type:4;
    unsigned notused:2;     /* Not used */
    unsigned encoding:4;
 
    unsigned lru:22;        /* lru time (relative to server.lruclock) */ lru = server.lruclock
    int refcount;
    void *ptr;
} robj;

每次访问该key时，即更新该key对应的value的最近访问时间为server.lruclock。 db.c:lookupKey()。
在读或者写时， 都会调用lookupKey更新。



int expireIfNeeded(redisDb *db, robj *key) {
    mstime_t when = getExpire(db,key);//得到设置的截止超时时间。 绝对时间。未设置超时则为-1。

    ....不符合超时条件，退出； 底下会处理超时。

    /* Delete the key */
    server.stat_expiredkeys++;
    propagateExpire(db,key);//将本次数据超时信息传递给slave、写AOF
    notifyKeyspaceEvent(REDIS_NOTIFY_EXPIRED, "expired",key,db->id);//将本次超时信息广播给相关订阅者。？
    return dbDelete(db,key);//从db.expires和db.dict中删除掉。
}


robj *lookupKey(redisDb *db, robj *key) {
    dictEntry *de = dictFind(db->dict,key->ptr);
    if (de) {
        robj *val = dictGetVal(de);

        /* Update the access time for the ageing algorithm.
         * Don't do it if we have a saving child, as this will trigger
         * a copy on write madness. */
        if (server.rdb_child_pid == -1 && server.aof_child_pid == -1)
            val->lru = server.lruclock;
        return val;
    } else {
        return NULL;
    }
}
robj *lookupKeyRead(redisDb *db, robj *key) {
    robj *val;

    expireIfNeeded(db,key);  //判断该key是否超时、超时就都淘汰--->底下的读就会失败、因为已经被淘汰了。
    val = lookupKey(db,key); //
    if (val == NULL)
        server.stat_keyspace_misses++;
    else
        server.stat_keyspace_hits++;
    return val;
}


redis.c:initServer中，增加定时器事件执行serverCron函数：
1)  该函数更新server.lruclock = (server.unixtime/REDIS_LRU_CLOCK_RESOLUTION) & REDIS_LRU_CLOCK_MAX;//server.unixtime =是通过time(NULL)得到的。
即server.lruclock 是当前时间/10 后结果的低21位。 
2)  执行databasesCron。该函数负责处理key的超时、rehash、resize。 其中key超时函数activeExpireCycle



void activeExpireCycle(int type) {
    /* This function has some global state in order to continue the work
     * incrementally across calls. */
    static unsigned int current_db = 0; /* Last DB tested. */从上次访问的db的下一个db接着开始处理
    static int timelimit_exit = 0;      /* Time limit hit in previous call? */
    static long long last_fast_cycle = 0; /* When last fast cycle ran. */

    unsigned int j, iteration = 0;
    unsigned int dbs_per_call = REDIS_DBCRON_DBS_PER_CALL;
    long long start = ustime(), timelimit;

    if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
        /* Don't start a fast cycle if the previous cycle did not exited
         * for time limt. Also don't repeat a fast cycle for the same period
         * as the fast cycle total duration itself. */
        
        //该变量为静态变量。上次函数未退出时， timelimit_exit为0； 1则退出。
        //由于本函数是由定时器事件触发，所以某些情况下可能有多个本函数在执行。
        if (!timelimit_exit) return;

        if (start < last_fast_cycle + ACTIVE_EXPIRE_CYCLE_FAST_DURATION*2) return;

        last_fast_cycle = start;

    }



    /* We usually should test REDIS_DBCRON_DBS_PER_CALL per iteration, with

     * two exceptions:

     *

     * 1) Don't test more DBs than we have.

     * 2) If last time we hit the time limit, we want to scan all DBs

     * in this iteration, as there is work to do in some DB and we don't want

     * expired keys to use memory for too much time. */

    if (dbs_per_call > server.dbnum || timelimit_exit)

        dbs_per_call = server.dbnum;



    /* We can use at max ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC percentage of CPU time

     * per iteration. Since this function gets called with a frequency of

     * server.hz times per second, the following is the max amount of

     * microseconds we can spend in this function. */

//ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 25.

//server.hz default值是 10. 那么timelimit约为25000. （与ustime比， 那么就是25ms）

    timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100;//
    timelimit_exit = 0;    if (timelimit <= 0) timelimit = 1;    if (type == ACTIVE_EXPIRE_CYCLE_FAST)        timelimit = ACTIVE_EXPIRE_CYCLE_FAST_DURATION; /*1000 in microseconds. */    for (j = 0; j < dbs_per_call; j++) {//dbs_per_call数据库个数。        int expired;        redisDb *db = server.db+(current_db % server.dbnum);//逐个db轮流处理。 每个db只处理        /* Increment the DB now so we are sure if we run out of time         * in the current DB we'll restart from the next. This allows to         * distribute the time evenly across DBs. */        current_db++;        /* Continue to expire if at the end of the cycle more than 25%         * of the keys were expired. */        do {            unsigned long num, slots;            long long now, ttl_sum;            int ttl_samples;            /* If there is nothing to expire try next DB ASAP. */            if ((num = dictSize(db->expires)) == 0) {                db->avg_ttl = 0;                break;            }            slots = dictSlots(db->expires);            now = mstime();            /* When there are less than 1% filled slots getting random             * keys is expensive, so stop here waiting for better times...             * The dictionary will be resized asap. */            if (num && slots > DICT_HT_INITIAL_SIZE &&                (num*100/slots < 1)) break;            /* The main collection cycle. Sample random keys among keys             * with an expire set, checking for expired ones. */            expired = 0;            ttl_sum = 0;            ttl_samples = 0;            if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)                num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;//20。。。。            while (num--) {                dictEntry *de;                long long ttl;                if ((de = dictGetRandomKey(db->expires)) == NULL) break;//取db->expires的随机桶的首元素                ttl = dictGetSignedIntegerVal(de)-now;                if (activeExpireCycleTryExpire(db,de,now)) expired++;//如果已经超时，则从db删掉、增加server.stat_expiredkeys                if (ttl < 0) ttl = 0;                ttl_sum += ttl;                ttl_samples++;            }            /* Update the average TTL stats for this database. */            if (ttl_samples) {                long long avg_ttl = ttl_sum/ttl_samples;                if (db->avg_ttl == 0) db->avg_ttl = avg_ttl;                /* Smooth the value averaging with the previous one. */                db->avg_ttl = (db->avg_ttl+avg_ttl)/2;            }            /* We can't block forever here even if there are many keys to             * expire. So after a given amount of milliseconds return to the             * caller waiting for the other active expire cycle. */            iteration++;            if ((iteration & 0xf) == 0 && /* check once every 16 iterations. */                (ustime()-start) > timelimit)            {                timelimit_exit = 1;            }            if (timelimit_exit) return;            /* We don't repeat the cycle if there are less than 25% of keys             * found expired in the current DB. */        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);    }//end for(int i=.., i < dbnum...)}