Redis数据库—键

最新推荐文章于 2024-09-25 11:06:23 发布

隔壁村王小黑

最新推荐文章于 2024-09-25 11:06:23 发布

阅读量473

点赞数 16

分类专栏： Redis 文章标签：数据库 redis 缓存

本文链接：https://blog.csdn.net/qq_25258019/article/details/138460364

版权

Redis 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

服务器中每个数据库由redis.h/redisDb结构表示，我们来看下键是如何管理和存储的。

typedef struct redisDb{
	//键空间，保存这数据库所有键值对的键
	dict *dict;
	//过期字典，保存键的过期时间
	dict *expires;
	//...
}

键空间

redisDb结构体使用字典保存数据库中的所有key称之为键空间，下图为键空间存储了三个key，分别是alphabet、book、message。数据库的增删改实质是对redisDb结构下dict字典进行操作。对数据库进行get操作实质就是获取redisDb结构体下dict字典里对应key指向的值对象。像FLUSHDB、KEYS、EXISTS等命令同样可以直接通过这个字典完成。

在这里插入图片描述

过期字典

redisDb结构体重expires字典保存了数据库中所有键的过期时间，称之为过期字典。过期字典的值是一个long类型整数，这个整数保存了键的过期时间，是一个UNIX毫秒时间戳。
在这里插入图片描述

过期键判定

通过过期字典，程序可以检查给定键是否过期：

检查给定键是否存在过期字典中，如果存在那么获取键的过期时间
检查键的过期时间是否大于当前UNIX毫秒时间戳，如果大于则未过期，反之过期了

过期键删除策略

Redis使用惰性删除+定期删除策略，使服务器可以在合理使用CPU和避免浪费内存之间取得平衡

惰性删除

每次从键空间获取键时，都检查键是否过期，如果过期的话就删除，否则返回该键

优点：不会在检查其它无关的非过期键上花费任何CPU时间
缺点：对内存不有好，如果一个键过期了但是一直没有访问，就一直存在内存中，无用的垃圾数据会占用大量内存，有内存泄漏的危险
惰性删除策略由db.c/expireIfNeeded函数实现，所有读写数据库的Redis命令在执行之前都会调用expireIfNeeded函数对键进行检查，流程图如下

定期删除

每隔一段时间，程序对数据库过期字典进行一次检查，删除里面的过期键，至于要删除多少过期键，检查多少数据库，由算法根据服务器情况而定。

难点：确定删除操作执行的时长和频率，如果执行时间短并且执行次数太少还是会造成内存浪费，反之操作太频繁将占用CPU资源

定期删除策略由redis.c/activeExpireCycle函数实现，执行流程如下：
1.遍历各个数据库
2.从一个数据库中取出一定数量的随机键进行检查，并删除其中过期键
3.全局变量current_db记录当前activeExpireCycle函数检查的进度，并为下次调用时接着上次进度进行处理
4.随着函数不断执行，服务器中数据库所有键都会被检查一遍，此时current_db变为0
5.重新开始新一轮的检查

以下为redis.c/activeExpireCycle函数源码

void activeExpireCycle(int type) {
    // 静态变量，用来累积函数连续执行时的数据
    static unsigned int current_db = 0; /* Last DB tested. */
    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) {
        // 如果上次函数没有触发 timelimit_exit ，那么不执行处理
        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:
     *
     * 一般情况下，函数只处理 REDIS_DBCRON_DBS_PER_CALL 个数据库，
     * 除非：
     *
     * 1) Don't test more DBs than we have.
     *    当前数据库的数量小于 REDIS_DBCRON_DBS_PER_CALL
     * 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;
    // 函数处理的微秒时间上限
    // ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 默认为 25 ，也即是 25 % 的 CPU 时间
    timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100;
    timelimit_exit = 0;
    if (timelimit <= 0) timelimit = 1;

    // 如果是运行在快速模式之下
    // 那么最多只能运行 FAST_DURATION 微秒 
    // 默认值为 1000 （微秒）
    if (type == ACTIVE_EXPIRE_CYCLE_FAST)
        timelimit = ACTIVE_EXPIRE_CYCLE_FAST_DURATION; /* in microseconds. */

    // 遍历数据库
    for (j = 0; j < dbs_per_call; j++) {
        int expired;
        // 指向要处理的数据库
        redisDb *db = server.db+(current_db % server.dbnum);
        // 为 DB 计数器加一，如果进入 do 循环之后因为超时而跳出
        // 那么下次会直接从下个 DB 开始处理
        current_db++;
        do {
            unsigned long num, slots;
            long long now, ttl_sum;
            int ttl_samples;

            /* If there is nothing to expire try next DB ASAP. */
            // 获取数据库中带过期时间的键的数量
            // 如果该数量为 0 ，直接跳过这个数据库
            if ((num = dictSize(db->expires)) == 0) {
                db->avg_ttl = 0;
                break;
            }
            // 获取数据库中键值对的数量
            slots = dictSlots(db->expires);
            // 当前时间
            now = mstime();
            // 这个数据库的使用率低于 1% ，扫描起来太费力了（大部分都会 MISS）
            // 跳过，等待字典收缩程序运行
            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 计数器
            ttl_sum = 0;
            // 总共处理的键计数器
            ttl_samples = 0;

            // 每次最多只能检查 LOOKUPS_PER_LOOP 个键
            if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
                num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;

            // 开始遍历数据库
            while (num--) {
                dictEntry *de;
                long long ttl;

                // 从 expires 中随机取出一个带过期时间的键
                if ((de = dictGetRandomKey(db->expires)) == NULL) break;
                // 计算 TTL
                ttl = dictGetSignedIntegerVal(de)-now;
                // 如果键已经过期，那么删除它，并将 expired 计数器增一
                if (activeExpireCycleTryExpire(db,de,now)) expired++;
                if (ttl < 0) ttl = 0;
                // 累积键的 TTL
                ttl_sum += ttl;
                // 累积处理键的个数
                ttl_samples++;
            }

            /* Update the average TTL stats for this database. */
            // 为这个数据库更新平均 TTL 统计数据
            if (ttl_samples) {
                // 计算当前平均值
                long long avg_ttl = ttl_sum/ttl_samples;
                
                // 如果这是第一次设置数据库平均 TTL ，那么进行初始化
                if (db->avg_ttl == 0) db->avg_ttl = avg_ttl;
                /* Smooth the value averaging with the previous one. */
                // 取数据库的上次平均 TTL 和今次平均 TTL 的平均值
                db->avg_ttl = (db->avg_ttl+avg_ttl)/2;
            }
            // 我们不能用太长时间处理过期键，
            // 所以这个函数执行一定时间之后就要返回

            // 更新遍历次数
            iteration++;

            // 每遍历 16 次执行一次
            if ((iteration & 0xf) == 0 && /* check once every 16 iterations. */
                (ustime()-start) > timelimit)
            {
                // 如果遍历次数正好是 16 的倍数
                // 并且遍历的时间超过了 timelimit
                // 那么断开 timelimit_exit
                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. */
            // 如果已删除的过期键占当前总数据库带过期时间的键数量的 25 %
            // 那么不再遍历
        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);
    }
}