Redis深度歷險-淘汰策略 Redis深度歷險-淘汰策略

Redis深度歷險-淘汰策略

Redis是內存型數據庫，在系統中如果佔用內存超過物理內存就會出現磁盤swap，這種操作就會導致性能急劇下降，所以纔會出現淘汰策略

Redis配置

Redis允許用戶配置使用的最大內存和超過最大內存時的處理策略

maxmemory：用於設置最大使用的內存

maxmemory-policy：超過最大內存時的處理策略

• noeviction：禁止寫入操作、允許讀取和刪除操作，這是默認配置
• volatile-lru：淘汰設置了過期時間的key，最少使用的key會被釋放掉
• volatile-lfu：淘汰設置了過期時間的key，某段時間內使用頻率最少的key會被釋放掉
• volatile-ttl：淘汰設置了過期時間的key，剩餘壽命ttl最少的key會被釋放掉
• volatile-random：淘汰設置了過期時間中的隨機key
• allkeys-lru：與volatile-lru類似，只是面向所有key
• allkeys-lfu：與volatile-lfu類似，只是面向所有key
• allkeys-random：與volatile-random類似，只是面向所有的key

Redis實現

Redis對象結構體

typedef struct redisObject {
    //數據類型，redis提供的5種類型
    unsigned type:4;
    //這種類型的底層實現方式，比如有序集合底層會使用鏈表或者壓縮列表實現
    unsigned encoding:4;
    unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or
                            * LFU data (least significant 8 bits frequency
                            * and most significant 16 bits access time). */
    //元素的引用計數
    int refcount;
    //元素的數據
    void *ptr;
} robj;

這裏主要需要關注的是lru字段，共24位

• 如果使用的是lru相關算法，則記錄的是最後訪問時間
• 如果使用的是lfu相關算法，則高16位記錄的是上次訪問時間（單位爲分）、低8位記錄的是某段時間的使用頻次

lru算法

Redis實現的是一種類似LRU的算法，主要是完全按照LRU的實現需要對現有數據結構做改造同時會消耗很多內存

1. 爲每個key添加一個24bit的字段，用於存儲最後訪問的時間戳
2. 隨機採樣出5個key，淘汰掉最舊的key
3. 將隨機採樣剩下的key放入到淘汰池中（一個數組）
4. 淘汰後內存依舊超出maxmemory，隨機採樣出5個key與淘汰池數據融合，淘汰掉最舊的key
5. 繼續3、4步驟，直到空間小於maxmemory

Redis的淘汰過程是一個阻塞的過程，直到清理出足夠的空間；如果內存達到maxmemory的限制並且客戶端還在不停的寫入，可能會導致反覆出發清理策略，導致請求延遲
淘汰池的大小由maxmemory-samples配置來控制，設置爲5-10之間即可

lfu算法

配置

• lfu-log-factor：設置計數器counter的增長速度
• lfu-decay-time：設置計數器counter的減少速度，以分鐘爲單位

更新lfu計數

void updateLFU(robj *val) {
    //將原本的訪問計數取出來
    unsigned long counter = LFUDecrAndReturn(val);
    //計數增長
    counter = LFULogIncr(counter);
    //將訪問計數設置到redisobj中
    val->lru = (LFUGetTimeInMinutes()<<8) | counter;
}

Redis中的lfu訪問計數增長或減少都不是簡單的-1而是通過一定的算法來實現的

unsigned long LFUDecrAndReturn(robj *o) {
    //分別取出上一次的訪問時間以及訪問計數
    unsigned long ldt = o->lru >> 8;
    unsigned long counter = o->lru & 255;
    //每超過lfu_decay_time的時間counter計數就需要減少一
    unsigned long num_periods = server.lfu_decay_time ? LFUTimeElapsed(ldt) / server.lfu_decay_time : 0;
    if (num_periods)
        counter = (num_periods > counter) ? 0 : counter - num_periods;
    return counter;
}

//計算出上一次訪問到現在的距離（以分鐘爲單位）
unsigned long LFUTimeElapsed(unsigned long ldt) {
    unsigned long now = LFUGetTimeInMinutes();
    if (now >= ldt) return now-ldt;
    return 65535-ldt+now;
}
unsigned long LFUGetTimeInMinutes(void) {
    return (server.unixtime/60) & 65535;
}

在RedisObject中存儲的時間是以分鐘爲單位然後對65535取模，最後得出的就是一個16位的時間

uint8_t LFULogIncr(uint8_t counter) {
    //最大的counter訪問計數就是255（8）位
    if (counter == 255) return 255;
    double r = (double)rand()/RAND_MAX;
    double baseval = counter - LFU_INIT_VAL;
    if (baseval < 0) baseval = 0;
    double p = 1.0/(baseval*server.lfu_log_factor+1);
    if (r < p) counter++;
    return counter;
}

這裏的計數增長操作最大隻能達到255，內部使用的是一種隨機算法，可能性隨計數的增大呈現：1.0/(baseval*server.lfu_log_factor+1)的規律，訪問次數越大增長的越慢

新生key

lfu算法會有一個問題就是新生key可能很快被淘汰掉

robj *createObject(int type, void *ptr) {
    robj *o = zmalloc(sizeof(*o));
    o->type = type;
    o->encoding = OBJ_ENCODING_RAW;
    o->ptr = ptr;
    o->refcount = 1;

    if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
        //新生的時候會設置一個默認值（5）
        o->lru = (LFUGetTimeInMinutes()<<8) | LFU_INIT_VAL;
    } else {
        o->lru = LRU_CLOCK();
    }
    return o;
}