IT俱乐部 Redis Redis过期时间的设计与实现代码

Redis过期时间的设计与实现代码

发布: 2024年 9月 6日 101阅读

1. 设置过期时间

Redis 提供了多个命令来设置键的过期时间，如 EXPIRE、PEXPIRE、EXPIREAT 和 PEXPIREAT。这些命令可以以秒或毫秒为单位设置键的过期时间，也可以设置具体的过期时间点。

  • EXPIRE key seconds
  • PEXPIRE key milliseconds
  • EXPIREAT key timestamp
  • PEXPIREAT key milliseconds-timestamp

示例：

void expireCommand(client *c) {
    long long seconds;
    if (getLongLongFromObjectOrReply(c, c->argv[2], &seconds, NULL) != C_OK)
        return;
    setExpire(c, c->db, c->argv[1], mstime() + seconds*1000);
    addReply(c, shared.cone);
}

2. 过期键的存储结构

每个 Redis 数据库实例（redisDb）中都有一个名为 expires 的字典，用于存储键的过期时间。这个字典将键指针映射到以毫秒为单位的到期时间点。

typedef struct redisDb {
    dict *dict;                // 主字典，存储所有键值对
    dict *expires;             // 过期字典，存储键的过期时间
    ...
} redisDb;

3. 设置过期时间

通过 setExpire 函数设置键的过期时间。如果键已经存在于 expires 字典中，则更新其过期时间；否则，将其添加到 expires 字典中。

void setExpire(client *c, redisDb *db, robj *key, long long when) {
    dictEntry *de = dictFind(db->dict, key->ptr);
    if (de == NULL) return;

    /* Set the new expire time */
    if (dictAdd(db->expires, dictGetKey(de), (void*)when) == DICT_ERR) {
        dictReplace(db->expires, dictGetKey(de), (void*)when);
    }
}

4. 删除过期键的策略

Redis 采用了以下三种策略来删除过期键：

  • 惰性删除（Lazy Deletion） ：每次访问键时检查其是否过期，如果已过期则删除。这样只在访问键时才进行过期检查，节省了资源。
robj *lookupKeyRead(redisDb *db, robj *key) {
    robj *val;
    expireIfNeeded(db,key);  // 检查并删除过期键
    val = lookupKey(db,key,LOOKUP_NONE);
    return val ? val : NULL;
}
  • 定期删除（Periodic Deletion） ：Redis 会周期性地随机抽取一定数量的键进行过期检查，并删除其中已过期的键。这一过程由后台任务定期执行，确保尽可能多的过期键被及时删除。
int activeExpireCycle(int type) {
    unsigned int current_db = server.dbnum;
    long long start = ustime();
    long long timelimit = 1000000; // 1秒
    int dbs_per_call = CRON_DBS_PER_CALL;

    current_db = server.current_db;
    while(dbs_per_call--) {
        redisDb *db = server.db + (current_db % server.dbnum);
        activeExpireCycleTryExpire(db, cycle_tickets);
        current_db++;
    }

    long long elapsed = ustime()-start;
    return elapsed > timelimit;
}
  • 主动删除（Active Expiration） ：在内存使用接近最大限制时，会触发主动删除策略，通过扫描所有库的键删除过期数据，以确保内存使用量保持在设定范围内。
void evictExpiredKeys() {
    for (int j = 0; j

  • Redis 默认采用以下两种删除过期键策略：

    惰性删除（Lazy Deletion） ：每次访问某个键时检查其是否过期，如果过期则删除。

    定期删除（Periodic Deletion） ：后台任务定期扫描数据库中的键，随机抽取部分键进行过期检查并删除其中已过期的键。

5. 检查并删除过期键

expireIfNeeded 函数用于检查某个键是否过期，如果过期则删除该键。

int expireIfNeeded(redisDb *db, robj *key) {
    mstime_t when = getExpire(db, key);
    if (when  when) {
        server.stat_expiredkeys++;
        propagateExpire(db,key);
        dbDelete(db,key);
        return 1;
    } else {
        return 0;
    }
}
  • getExpire：从 expires 字典中获取键的过期时间。
  • mstime：返回当前的毫秒时间戳。
  • 如果键已过期，则调用 dbDelete 删除该键，并增加统计计数器 stat_expiredkeys。

6. 获取过期时间

getExpire 函数用于获取键的过期时间，如果键没有设置过期时间则返回 -1。

mstime_t getExpire(redisDb *db, robj *key) {
    dictEntry *de;
    if (dictSize(db->expires) == 0 ||
        (de = dictFind(db->expires, key->ptr)) == NULL) return -1;

    return (mstime_t)dictGetSignedIntegerVal(de);
}

总结

Redis 的过期时间设计与实现包括以下几个关键点：

  • 设置过期时间：通过 EXPIRE、PEXPIRE 等命令设置键的过期时间，并将过期时间存储在 expires 字典中。

  • 过期字典：每个数据库实例都有一个 expires 字典，用于存储键的过期时间。

  • 删除策略：

    • 惰性删除：每次访问键时检查其是否过期，如果已过期则删除。
    • 定期删除：通过后台任务周期性地检测并删除过期键。
    • 主动删除：在内存使用接近最大限制时触发，扫描所有键并删除过期键。

定期删除activeExpireCycle函数详细解析

void activeExpireCycle(int type) {
    static unsigned int current_db = 0;  // 记录上一次处理的数据库索引
    static int timelimit_exit = 0;       // 用于指示是否超出时间限制
    unsigned int j;
    // 每次要处理的数据库数量
    unsigned int dbs_per_call = CRON_DBS_PER_CALL;
    long long start = ustime();          // 开始时间
    long long timelimit;                 // 时间限制

    if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
        /* Fast cycle: 1 ms */
        timelimit = 1000;
    } else {
        /* Slow cycle: 25% CPU time p. DB / Configurable percentage. */
        timelimit = server.hz expires)) != NULL &&
                   mstime() - now dict, dictGetKey(de));
                    dbDelete(db, dictGetKey(d));
                    server.stat_expiredkeys++;
                    expired++;
                }
                sampled++;
            }
        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP / 2);

        elapsed = ustime() - start;
        if (elapsed > timelimit) {
            timelimit_exit = 1;
            break;
        }
    }
}

关键步骤解析

1. 初始化变量

static unsigned int current_db = 0;
static int timelimit_exit = 0;
unsigned int j;
unsigned int dbs_per_call = CRON_DBS_PER_CALL;
long long start = ustime();
long long timelimit;
  • current_db：静态变量，用于记录上一次处理的数据库索引。
  • timelimit_exit：用于指示是否耗尽了时间配额，防止无限循环。
  • dbs_per_call：每次扫描的数据库数量，通常由配置决定。
  • start：记录开始执行此函数的时间戳。
  • timelimit：本次调用允许消耗的最大时间（以微秒为单位）。

2. 确定时间限制

if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
    timelimit = 1000;  // 快速模式：1 毫秒
} else {
    timelimit = server.hz
  • 如果是快速模式，时间限制为 1 毫秒。
  • 如果是慢速模式，时间限制根据 Redis 配置和当前服务器负载情况计算。
  • server.active_expire_effort 参数可以调整过期键清理的力度。

3. 遍历数据库

每次调用 activeExpireCycle 时，会遍历一定数量的数据库，并在每个数据库中随机抽取键进行过期检查和删除。

for (j = 0; j expires)) != NULL &&
               mstime() - now dict, dictGetKey(de));
                dbDelete(db, dictGetKey(d));
                server.stat_expiredkeys++;
                expired++;
            }
            sampled++;
        }
    } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP / 2);

    elapsed = ustime() - start;
    if (elapsed > timelimit) {
        timelimit_exit = 1;
        break;
    }
}

关键点解析：

选择数据库：

redisDb *db = server.db + (current_db % server.dbnum);
current_db++;

使用循环方式选择下一个要检查的数据库实例。current_db 记录上一次处理的数据库索引，通过取模操作确保索引在有效范围内。

初始化变量：

int expired, sampled;
expired = 0;
sampled = 0;

过期检查循环：

while ((de = dictGetRandomKey(db->expires)) != NULL && mstime() - now dict, dictGetKey(de));
        dbDelete(db, dictGetKey(d));
        server.stat_expiredkeys++;
        expired++;
    }
    sampled++;
}
    • 从 expires 字典中随机获取一个键 de。
    • 检查当前时间是否超过了本次周期的时间限制 timelimit。
    • 如果键已经过期（ttl ），则删除该键，并增加已过期键的计数器 expired。
    • 增加已检查键的计数器 sampled。

多轮过期检查：

do {
    ...
} while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP / 2);

  • 如果在一轮检查中删除的过期键数量超过预设值的一半，则继续下一轮检查。

4. 时间限制检查

在每次处理完一个数据库后，检查是否超出时间限制：

elapsed = ustime() - start;
if (elapsed > timelimit) {
    timelimit_exit = 1;
    break;
}
  • 计算已耗费的时间 elapsed。
  • 如果已耗费时间超过 timelimit，设置 timelimit_exit 为 1 并跳出循环。

总结

Redis 的 activeExpireCycle 函数通过以下步骤实现定期删除过期键：

  • 初始化变量并确定时间限制：根据当前的模式（快速或慢速）和配置参数，计算本次函数调用的时间限制。
  • 遍历数据库：循环遍历一定数量的数据库。
  • 过期检查与删除：从每个数据库中随机抽取键，检查其是否过期并进行删除，直到达到时间限制或删除了一定数量的过期键。
  • 时间限制检查：确保函数不会超出规定的时间配额，以避免影响 Redis 的其他操作。

AOF、RDB和复制功能对过期键的处理

在 Redis 中，AOF（Append Only File）、RDB（Redis DataBase）和复制（Replication）功能对过期键的处理方式有所不同。下面详细介绍这些机制如何处理过期键：

AOF 持久化

  • 记录过期时间：

    • 在 AOF 文件中，除了写入每个键值的设置操作外，还会写入 EXPIRE 或 PEXPIRE 命令来记录键的过期时间。

  • 重写（Rewrite）过程：

    • 当 AOF 文件需要重写时，Redis 会检查每个键，如果键已过期，则不会将其写入新的 AOF 文件。

  • 加载 AOF 文件：

    • 当 Redis 重启并加载 AOF 文件时，会执行文件中的所有命令，包括设置键值和设置过期时间的命令。如果某些键已经过期，这些键会立即被删除。

RDB 持久化

  • 保存快照：

    • 当 Redis 创建 RDB 快照时，它会将所有键及其剩余的过期时间一起保存到快照文件中。

  • 加载快照：

    • 当 Redis 从 RDB 文件恢复数据时，会载入所有键值对，同时载入它们的过期时间。如果某个键在载入时已经过期，Redis 会立即将其删除。

复制（Replication）

  • 主从同步：

    • 在主从复制架构中，主节点会将过期键的删除操作传播给从节点。
    • 如果一个键在主节点上过期并被删除，主节点会向从节点发送 DEL 操作，从而在从节点上也删除该键。

  • 延迟过期：

    • 从节点可能因为网络延迟等原因，对过期键的处理会稍有滞后，但最终主从节点的数据将保持一致。

总结

  • AOF:

    • 通过记录 EXPIRE/PEXPIRE 命令来处理过期时间。
    • 在重写过程中跳过已过期的键。
    • 加载时删除已过期的键。

  • RDB:

    • 将过期时间与键值一起保存。
    • 加载时立即删除已过期的键。

  • 复制:

    • 主节点将删除过期键的操作同步到从节点。
    • 确保主从节点数据的一致性。

以上就是Redis过期时间的设计与实现代码的详细内容，更多关于Redis过期时间的资料请关注IT俱乐部其它相关文章！

本文收集自网络，不代表IT俱乐部立场，转载请注明出处。https://www.2it.club/database/redis/12831.html
13赞
标签:
上一篇
下一篇

相关推荐

联系我们

联系我们

在线咨询: QQ交谈

邮箱: 1120393934@qq.com

工作时间：周一至周五，9:00-17:30，节假日休息

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

返回顶部