深入浅出-Redis过期删除策略手术式源码刨析，小白也能看懂

之前就说了要来西索Redis，现在来辣！本文的部分基础内容参考自《小林Coding》，深入的地方根据源代码进行剖析。 Redis源码地址：github.com/redis/redis...

过期删除策略

基础的命令就不做过多解释了，如下

expire <key> <n>：设置 key 在 n 秒后过期，比如 expire key 100 表示设置 key 在 100 秒后过期；
pexpire <key> <n>：设置 key 在 n 毫秒后过期，比如 pexpire key2 100000 表示设置 key2 在 100000 毫秒（100 秒）后过期。
expireat <key> <n>：设置 key 在某个时间戳（精确到秒）之后过期，比如 expireat key3 1655654400 表示 key3 在时间戳 1655654400 后过期（精确到秒）；
pexpireat <key> <n>：设置 key 在某个时间戳（精确到毫秒）之后过期，比如 pexpireat key4 1655654400000 表示 key4 在时间戳 1655654400000 后过期（精确到毫秒）

当然，在设置字符串时，也可以同时对 key 设置过期时间，共有 3 种命令：

set <key> <value> ex <n> ：设置键值对的时候，同时指定过期时间（精确到秒）；
set <key> <value> px <n> ：设置键值对的时候，同时指定过期时间（精确到毫秒）；
setex <key> <n> <valule> ：设置键值对的时候，同时指定过期时间（精确到秒）。

查询和删除过期指令

TTL <key>
PERSIST <key>

判断过期

我们回到第一章（神奇，Redis存储原理竟然是这样！ -- Karos (wzl.fyi)），当时讲过Redis存储结构

c 复制代码

/* Redis database representation. There are multiple databases identified
 * by integers from 0 (the default database) up to the max configured
 * database. The database number is the 'id' field in the structure. */
//Redis数据库结构，通过ID来识别多个数据库
typedef struct redisDb {
    // 当前数据口的所有键值对空间
    dict *dict;                 /* The keyspace for this DB */
    // 存放已设置exptime的key的集合
    dict *expires;              /* Timeout of keys with a timeout set */
	....
  	....
    // 数据库id
    int id;                     /* Database ID */
    // 数据库的平均TTL
    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. */
    clusterSlotToKeyMapping *slots_to_keys; /* Array of slots to keys. Only used in cluster mode (db 0). */
} redisDb;

那么expires中entry的key和value代表什么呢？

key：某个键对象
value：long long类型的整数，表示key的过期时间

当我们在dict查找一个key的之前，先检查这个key是否存在于expires的哈希表中，如果不存在，继续查找，存在的话获取过期时间和系统时间比较，判断是否过期。

当然，还有个判断过期的函数

c 复制代码

// db.c
/* Check if the key is expired. */
int keyIsExpired(redisDb *db, robj *key) {
    /* Don't expire anything while loading. It will be done later. */
    if (server.loading) return 0;	// 如果redis服务器还在启动 ，俺么这个时候还没有过期key，直接 发安徽0

    mstime_t when = getExpire(db,key);		//获取key的过期时间
    mstime_t now;

    if (when < 0) return 0; /* No expire for this key */

    now = commandTimeSnapshot();

    /* The key expired if the current (virtual or real) time is greater
     * than the expire time of the key. */
    return now > when;
}

/* Return the expire time of the specified key, or -1 if no expire
 * is associated with this key (i.e. the key is non volatile) */
long long getExpire(redisDb *db, robj *key) {
    dictEntry *de;

    /* No expire? return ASAP */
    if (dictSize(db->expires) == 0 ||
       (de = dictFind(db->expires,key->ptr)) == NULL) return -1;	// 当在epxires哈希表中不能存在，就返回-1

    /* The entry was found in the expire dict, this means it should also
     * be present in the main dict (safety check). */
    serverAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);	// 日志输出
    // 放回过期时间
    return dictGetSignedIntegerVal(de);
}

int64_t dictGetSignedIntegerVal(const dictEntry *de) {
    assert(entryHasValue(de));
    return de->v.s64;
}

删除策略

常见的删除策略有3中

定时删除

在设置 key 的过期时间时，同时创建一个定时事件，当时间到达时，由事件处理器自动执行 key 的删除操作。

定时事件，虽然说可以及时释放内存，但是一定会长时间占用cpu，少量键还好，当键的数量够多的时候，无疑会大大降低服务器的吞吐量，所以Redis并未采用。
惰性删除
定期删除

而惰性删除和定期删除我们在下文细说

惰性删除

不主动删除过期键，每次从数据库访问 key 时，都检测 key 是否过期，如果过期则删除该 key。

那么我很多键都过期了，这时候我也不访问，就一直不删除，像垃圾一样占用内存，这个方法对cpu占用很少，特别友好，但是对于内存来说，那有可能是巨大的灾难。

哎，其实就是在之前判断过期的方法上面加了个删除，看看Redis的实现吧。

c 复制代码

/* Flags for expireIfNeeded */
#define EXPIRE_FORCE_DELETE_EXPIRED 1		// 二进制为 01
#define EXPIRE_AVOID_DELETE_EXPIRED 2		// 二进制为 10

// 用处是检验一个键是否过期，并不一定会删除，下面是官方对于这个函数的解释
/* This function is called when we are going to perform some operation
 * in a given key, but such key may be already logically expired even if
 * it still exists in the database. The main way this function is called
 * is via lookupKey*() family of functions.
 *
 * The behavior of the function depends on the replication role of the
 * instance, because by default replicas do not delete expired keys. They
 * wait for DELs from the master for consistency matters. However even
 * replicas will try to have a coherent return value for the function,
 * so that read commands executed in the replica side will be able to
 * behave like if the key is expired even if still present (because the
 * master has yet to propagate the DEL).
 *
 * In masters as a side effect of finding a key which is expired, such
 * key will be evicted from the database. Also this may trigger the
 * propagation of a DEL/UNLINK command in AOF / replication stream.
 *
 * On replicas, this function does not delete expired keys by default, but
 * it still returns 1 if the key is logically expired. To force deletion
 * of logically expired keys even on replicas, use the EXPIRE_FORCE_DELETE_EXPIRED
 * flag. Note though that if the current client is executing
 * replicated commands from the master, keys are never considered expired.
 *
 * On the other hand, if you just want expiration check, but need to avoid
 * the actual key deletion and propagation of the deletion, use the
 * EXPIRE_AVOID_DELETE_EXPIRED flag.
 *
 * The return value of the function is 0 if the key is still valid,
 * otherwise the function returns 1 if the key is expired. */
int expireIfNeeded(redisDb *db, robj *key, int flags) {
    if (server.lazy_expire_disabled) return 0;	// 判断是否开启惰性删除
    /**
     * 没有过期就不删除，这一块儿的源代码我们在上面就已经讲过了
     * 要注意的是，判断键是否过期，里面使用了DictFind方法来查找键值对
     * 这个方法在使用的时候会判断是否处于渐进式Hash的过程中，如果是的话，会执行一次部分ReHash。
    **/
    if (!keyIsExpired(db,key)) return 0;		


    // 如果当前Redis数据库是从库，那么将数据返回，我们要保证数据和主库的一致性，从库删除数据是从主库广播DEL命令来进行删除的
    if (server.masterhost != NULL) {
        /**
         * 在从库上，默认情况下，该函数不会删除过期的键，但如果键在逻辑上已过期，它仍然会返回1。
         * 要强制在从库上删除逻辑上过期的键，请使用EXPIRE_FORCE_DELETE_EXPIRED标志。
         * 注意，如果当前客户端正在从主库执行复制命令，则永远不会认为键已过期。
        */
        if (server.current_client && (server.current_client->flags & CLIENT_MASTER)) return 0;
        // 下面这个语句用的比较妙，对于flag，我们可以选择1[01]和2[10]来进行&运算，当强制删除的时候，就会往下面运行
        if (!(flags & EXPIRE_FORCE_DELETE_EXPIRED)) return 1;
    }

    /* In some cases we're explicitly instructed to return an indication of a
     * missing key without actually deleting it, even on masters. */
    // 如果只需要检查过期情况，但需要避免实际删除键并传播删除操作，请使用EXPIRE_AVOID_DELETE_EXPIRED标志
    if (flags & EXPIRE_AVOID_DELETE_EXPIRED)
        return 1;

    /* If 'expire' action is paused, for whatever reason, then don't expire any key.
     * Typically, at the end of the pause we will properly expire the key OR we
     * will have failed over and the new primary will send us the expire. */
    // 有时候会暂停过期key的处理，但是这个时候我们依然返回1，就当是一个过期检测吧
    if (isPausedActionsWithUpdate(PAUSE_ACTION_EXPIRE)) return 1;

    /* Delete the key */
    deleteExpiredKeyAndPropagate(db,key);
    return 1;
}

官方解释的大概意思如下：该函数在执行某些操作时被调用，操作可能针对给定的键，但即使该键仍然存在于数据库中，它可能已经逻辑上过期了。

主要通过lookupKey*()函数系列调用该函数。
函数的行为取决于实例的复制角色，因为默认情况下从库不会删除过期的键。它们等待主库发送DEL命令以确保一致性。
不过，即使在从库上，该函数仍会努力返回一致的值，这样在从库执行的读取命令将能够像键已过期一样执行，
即使键仍然存在（因为主库尚未传播DEL命令）。
在主库上，发现过期键的副作用是将该键从数据库中逐出。这也可能触发AOF/复制流中的DEL/UNLINK命令的传播。
在从库上，默认情况下，该函数不会删除过期的键，但如果键在逻辑上已过期，它仍然会返回1。
要强制在从库上删除逻辑上过期的键，请使用EXPIRE_FORCE_DELETE_EXPIRED标志。
注意，如果当前客户端正在从主库执行复制命令，则永远不会认为键已过期。
另一方面，如果只需要检查过期情况，但需要避免实际删除键并传播删除操作，请使用EXPIRE_AVOID_DELETE_EXPIRED标志。
函数的返回值为0，如果键仍然有效，否则如果键已过期，则返回1。

定期删除

每隔一段时间==随机==从数据库中取出一定数量的 key 进行检查，并删除其中的过期key。

通过限制操作时长和频率，来减少对cpu的影响，同时也只能删除一部分数据。

所以这样会导致：部分数据可能删除不了，内存清理效果没有定时删除好，同时对操作系统的小号也没有惰性删除好，并且频率和操作时长难以控制。

在讲源码之前，我们先补充一些数据结构：

c 复制代码

// Data used by the expire dict scan callback.  这个结构用于回调扫描，后面细说
 typedef struct {
     redisDb *db;
     long long now;		   // 当前时间戳
     unsigned long sampled; // num keys checked 已抽样的键数量
     unsigned long expired; // num keys expired 过期键数量
     long long ttl_sum; // sum of ttl for key with ttl not yet expired 尚未过期键的过期时间总和
   	 int ttl_samples; // num keys with ttl not yet expired 尚未过期键的数量
  } expireScanData;

下面我们来看看源码是如何解释的，官方的解释我使用chatgpt简单翻译了一下

c 复制代码

/* Try to expire a few timed out keys. The algorithm used is adaptive and
 * will use few CPU cycles if there are few expiring keys, otherwise
 * it will get more aggressive to avoid that too much memory is used by
 * keys that can be removed from the keyspace.
 *
 * 尝试过期一些已超时的键。算法是自适应的，如果有很少过期键，则消耗很少的CPU周期；否则，它会更加积极，以避免过多的内存被可删除的键占用。
 *
 * Every expire cycle tests multiple databases: the next call will start
 * again from the next db. No more than CRON_DBS_PER_CALL databases are
 * tested at every iteration.
 *
 * 每个过期周期测试多个数据库：下一次调用将从下一个数据库开始。每次迭代最多测试 CRON_DBS_PER_CALL 个数据库。
 *
 * The function can perform more or less work, depending on the "type"
 * argument. It can execute a "fast cycle" or a "slow cycle". The slow
 * cycle is the main way we collect expired cycles: this happens with
 * the "server.hz" frequency (usually 10 hertz).
 *
 * 此函数根据"type"参数可以执行更多或更少的工作。
 * 它可以执行 "快速循环" 或 "慢速循环"。
 * 慢速循环是主要收集已过期键的方式：通常在每秒 server.hz 的频率下执行（通常为 10 次/秒）。
 *
 * However the slow cycle can exit for timeout, since it used too much time.
 * For this reason the function is also invoked to perform a fast cycle
 * at every event loop cycle, in the beforeSleep() function. The fast cycle
 * will try to perform less work, but will do it much more often.
 *
 * 然而，慢速循环可能因为超时而退出，因为它消耗了太多时间。
 * 因此，该函数还会在每个事件循环周期中执行 "快速循环"，在 beforeSleep() 函数中执行。
 * 快速循环会尝试执行较少的工作，但会更频繁地执行。
 *
 * The following are the details of the two expire cycles and their stop
 * conditions:
 *
 * If type is ACTIVE_EXPIRE_CYCLE_FAST the function will try to run a
 * "fast" expire cycle that takes no longer than ACTIVE_EXPIRE_CYCLE_FAST_DURATION
 * microseconds, and is not repeated again before the same amount of time.
 * The cycle will also refuse to run at all if the latest slow cycle did not
 * terminate because of a time limit condition.
 * 
 * 如果 type 为 ACTIVE_EXPIRE_CYCLE_FAST，函数将尝试运行一个 "快速" 过期周期，
 * 该周期的执行时间不超过 ACTIVE_EXPIRE_CYCLE_FAST_DURATION 微秒，并且在相同时间内不会再次重复执行。
 * 如果最近的慢速循环没有因时间限制条件而终止，该循环将拒绝运行。
 *
 * If type is ACTIVE_EXPIRE_CYCLE_SLOW, that normal expire cycle is
 * executed, where the time limit is a percentage of the REDIS_HZ period
 * as specified by the ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC define. In the
 * fast cycle, the check of every database is interrupted once the number
 * of already expired keys in the database is estimated to be lower than
 * a given percentage, in order to avoid doing too much work to gain too
 * little memory.
 *
 * 如果 type 为 ACTIVE_EXPIRE_CYCLE_SLOW，则执行正常的过期循环，其中的时间限制是 REDIS_HZ 周期的百分比，由 
 * ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 定义指定。
 * 在快速循环中，一旦估计数据库中已过期键的数量低于给定的百分比，对每个数据库的检查将被中断，以避免做太多的工作而获得太少的内存。
 *
 * The configured expire "effort" will modify the baseline parameters in
 * order to do more work in both the fast and slow expire cycles.
 */

/* Keys for each DB loop. */
#define ACTIVE_EXPIRE_CYCLE_KEYS_PER_LOOP 20  	// 每次随机抽查的数量
/* Microseconds. */
#define ACTIVE_EXPIRE_CYCLE_FAST_DURATION 1000 	// 快速过期扫描的最长执行时间（以微秒为单位）
/* Max % of CPU to use. */
#define ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 25 	// 每次循环允许使用的最大CPU占用百分比
/* % of stale keys after which we do extra efforts. */
#define ACTIVE_EXPIRE_CYCLE_ACCEPTABLE_STALE 10	// 每个周期内允许的过期键百分比，如果某个数据库过期键超过这个百分比，那该数据库会被处理。

#define ACTIVE_EXPIRE_CYCLE_SLOW 0
#define ACTIVE_EXPIRE_CYCLE_FAST 1

#define CRON_DBS_PER_CALL 16	// 数据库总数


void activeExpireCycle(int type) {
    /* 根据配置的过期努力程度(effort)调整运行参数。
     * 默认努力程度是1，最大可配置努力程度是10。 */
    unsigned long
    effort = server.active_expire_effort-1, /* Rescale from 0 to 9. */
    // 每次周期允许最多可以处理的key的数量
    config_keys_per_loop = ACTIVE_EXPIRE_CYCLE_KEYS_PER_LOOP +
                           ACTIVE_EXPIRE_CYCLE_KEYS_PER_LOOP/4*effort,
    // 每次快循环周期允许的最长时间 1s -> 3.25s
    config_cycle_fast_duration = ACTIVE_EXPIRE_CYCLE_FAST_DURATION +
                                 ACTIVE_EXPIRE_CYCLE_FAST_DURATION/4*effort,
    // 每次正常循环周期允许占用cpu的占比 25% -> 43%
    config_cycle_slow_time_perc = ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC +
                                  2*effort,
    // 每个周期内允许的过期键百分比。随着努力程度的增加，允许的过期键百分比会减少。
    config_cycle_acceptable_stale = ACTIVE_EXPIRE_CYCLE_ACCEPTABLE_STALE-
                                    effort;

    /* This function has some global state in order to continue the work
     * incrementally across calls. */
    static unsigned int current_db = 0; /* Next DB to test. */					// 下一个要处理的数据库ID
    static int timelimit_exit = 0;      /* Time limit hit in previous call? */	// 上一次是否因为时间限制退出
    static long long last_fast_cycle = 0; /* When last fast cycle ran. */		// 上一次快速扫描的时间

    int j, iteration = 0;
    int dbs_per_call = CRON_DBS_PER_CALL;					// 被处理的数据库总数
    long long start = ustime(), timelimit, elapsed;

    /* If 'expire' action is paused, for whatever reason, then don't expir                                                                  e any key.
     * Typically, at the end of the pause we will properly expire the key OR we
     * will have failed over and the new primary will send us the expire. */
    if (isPausedActionsWithUpdate(PAUSE_ACTION_EXPIRE)) return;	// 这个方法在讲惰性删除的时候就已经讲过了
	// 如果传入类型是快速循环处理
    if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
        /* Don't start a fast cycle if the previous cycle did not exit
         * for time limit, unless the percentage of estimated stale keys is
         * too high. Also never repeat a fast cycle for the same period
         * as the fast cycle total duration itself. */
        if (!timelimit_exit &&
            /*
            在redisServer中有一个字段
            double stat_expired_stale_perc; // Percentage of keys probably expired
            这个字段表示Key可能已过期的百分比，没有超过那么就还能接受，就不处理
            */
            server.stat_expired_stale_perc < config_cycle_acceptable_stale)
            return;
			/**
			* 如果开始时间在距离上一次开始的两个周期以内
			*/
        if (start < last_fast_cycle + (long long)config_cycle_fast_duration*2)
            return;
		// 记录快速循环
        last_fast_cycle = start;
    }
 
    /* We usually should test CRON_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)
        /**
       	 * #define REDIS_DEFAULT_DBNUM 16
         * // redisServer中使用的数据库实际总数，默认值为16
         * int dbnum;                      /* Total number of configured DBs .*/
         */
        dbs_per_call = server.dbnum;

    /* We can use at max 'config_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. */
    // 根据CPU使用率的阙值和ServerCPU执行频率HZ来进行计算时间限制
    timelimit = config_cycle_slow_time_perc*1000000/server.hz/100;
    timelimit_exit = 0;		//清空强制退出状态
    if (timelimit <= 0) timelimit = 1;	// 默认状态下，1ms为时间上限
	// 如果是快循环，修改时间上限
    if (type == ACTIVE_EXPIRE_CYCLE_FAST)
        timelimit = config_cycle_fast_duration; /* in microseconds. */

    /* Accumulate some global stats as we expire keys, to have some idea
     * about the number of keys that are already logically expired, but still
     * existing inside the database. */
    //  用于累积全局的过期键状态，以了解已经过期但仍存在于数据库中的键的数量。
    long total_sampled = 0;	// 总共已抽样的键的个数
    long total_expired = 0; // 总共过期的键的个数

    /* Try to smoke-out bugs (server.also_propagate should be empty here) */
    serverAssert(server.also_propagate.numops == 0);

    for (j = 0; j < dbs_per_call && timelimit_exit == 0; j++) {
        /* Scan callback data including expired and checked count per iteration. */
        expireScanData data;
        /**
         *  // Data used by the expire dict scan callback. 
         *  typedef struct {
         *      redisDb *db;
         *      long long now;		   // 当前时间戳
         *      unsigned long sampled; // num keys checked 已抽样的键数量
         *      unsigned long expired; // num keys expired 过期键数量
         *      long long ttl_sum; // sum of ttl for key with ttl not yet expired 尚未过期键的过期时间总和
         *      int ttl_samples; // num keys with ttl not yet expired 尚未过期键的数量
         *  } expireScanData;
         **/
        // 这里开始获取到本次循环需要清理的DB
        redisDb *db = server.db+(current_db % server.dbnum);
        data.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 there are still
         * a big percentage of keys to expire, compared to the number of keys
         * we scanned. The percentage, stored in config_cycle_acceptable_stale
         * is not fixed, but depends on the Redis configured "expire effort". */
        do {
            unsigned long num, slots;
            iteration++;

            /* If there is nothing to expire try next DB ASAP. */
            if ((num = dictSize(db->expires)) == 0) {
                db->avg_ttl = 0;		//当前没有过期键，那么平均过期时间就是0
                break;
            }
             /**
             这里是如何计算哈希桶数的
             #define dictSlots(d) 
            	(DICTHT_SIZE(
            		(d)->ht_size_exp[0]
                      )+
               DICTHT_SIZE(
                 (d)->ht_size_exp[1])
            	      )             
             **/
            slots = dictSlots(db->expires);	// 获取哈希桶的数目
            data.now = mstime();	// 记录当前时间

            /* When there are less than 1% filled slots, sampling the key
             * space is expensive, so stop here waiting for better times...
             * The dictionary will be resized asap. */
            if (slots > DICT_HT_INITIAL_SIZE &&
                (num*100/slots < 1)) break;		// 如果平均每个桶分配的过期键（过期键填充比例）小于1%，break，等待下次抽样

            /* The main collection cycle. Scan through keys among keys
             * with an expire set, checking for expired ones. */
            // 每次遍历都要重新计算，最后再累加
            data.sampled = 0;
            data.expired = 0;
            data.ttl_sum = 0;
            data.ttl_samples = 0;
			// num = dictSize(db->expires);
            // 修改key的处理量，不可以超过config_keys_per_loop最多可以处理的key的数量
            if (num > config_keys_per_loop)
                num = config_keys_per_loop;

            /* Here we access the low level representation of the hash table
             * for speed concerns: this makes this code coupled with dict.c,
             * but it hardly changed in ten years.
             *
             * Note that certain places of the hash table may be empty,
             * so we want also a stop condition about the number of
             * buckets that we scanned. However scanning for free buckets
             * is very fast: we are in the cache line scanning a sequential
             * array of NULL pointers, so we can scan a lot more buckets
             * than keys in the same time. */
            long max_buckets = num*20;	// 用于限制扫描哈希桶的数量，20是根据实验测得的。。。
            long checked_buckets = 0;

            while (data.sampled < num && checked_buckets < max_buckets) {
                // dictScan 函数是 Redis 中用于遍历字典（哈希表）的函数，它的作用是在哈希表中迭代键值对，并通过回调函数对每个键值对进行处理。
                // 这里expires_cursor感觉像是HashCode一样（呃呃呃，具体看后面跟随源码），可以用于确认索引位域哪个哈希桶
                // expires_cursor 是用于遍历哈希表的游标值（cursor），通常是一个哈希值（hash value）。
                // 在过期键处理的过程中，expires_cursor 用于指示当前迭代的起始位置，从而控制扫描哈希表的开始点。
                // 再回调的时候就已经将过期的数据进行删除了
                db->expires_cursor = dictScan(db->expires, db->expires_cursor,
                                              expireScanCallback, &data);
                checked_buckets++;
            }
            // 因为expired和sampled在遍历回调的时候进行了累加，所以这里得加上
            total_expired += data.expired;
            total_sampled += data.sampled;

            /* Update the average TTL stats for this database. */
            if (data.ttl_samples) {
                long long avg_ttl = data.ttl_sum / data.ttl_samples;

                /* Do a simple running average with a few samples.
                 * We just use the current estimate with a weight of 2%
                 * and the previous estimate with a weight of 98%. */
                if (db->avg_ttl == 0) db->avg_ttl = avg_ttl;
                db->avg_ttl = (db->avg_ttl/50)*49 + (avg_ttl/50);
            }

            /* 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. */
            // 每16次迭代检查一次是否超时（16个是因为默认是16个数据库），并完成记录，
            // 同时更新timelimit_exit=1，后续会开启fast-expire模式。
            if ((iteration & 0xf) == 0) { /* check once every 16 iterations. */
                elapsed = ustime()-start;
                // 超时退出
                if (elapsed > timelimit) {
                    timelimit_exit = 1;
                    server.stat_expired_time_cap_reached_count++; //用来记录被动过期键删除超时次数
                    break;
                }
            }
            /* We don't repeat the cycle for the current database if there are
             * an acceptable amount of stale keys (logically expired but yet
             * not reclaimed). */
        } while (data.sampled == 0 ||	// 如果还没有开始检测 or
                 // 当当前数据库已过期的数量/抽样的数量 > 10%-effort，这个地方写成*100是为了防止数据溢出
                 (data.expired * 100 / data.sampled) > config_cycle_acceptable_stale);	
    }

    elapsed = ustime()-start;
    // 用于统计定期删除总共耗费的时间
    // long long stat_expire_cycle_time_used; /* Cumulative microseconds used. */
    server.stat_expire_cycle_time_used += elapsed;
    latencyAddSampleIfNeeded("expire-cycle",elapsed/1000);// 将耗时补加到Redis延迟统计中

    /* Update our estimate of keys existing but yet to be expired.
     * Running average with this sample accounting for 5%. */
     /* 更新已过期但仍未被删除的键的估算数量。
     * 通过这个样本估算平均存在的过期键的百分比，权重为5%。 */
    double current_perc;
    if (total_sampled) {
        current_perc = (double)total_expired/total_sampled;
    } else
        current_perc = 0;
    server.stat_expired_stale_perc = (current_perc*0.05)+
                                     (server.stat_expired_stale_perc*0.95);
}

unsigned long dictScan(dict *d,
                       unsigned long v,
                       dictScanFunction *fn,
                       void *privdata)
{
    return dictScanDefrag(d, v, fn, NULL, privdata);
}

/* Like dictScan, but additionally reallocates the memory used by the dict
 * entries using the provided allocation function. This feature was added for
 * the active defrag feature.
 *
 * The 'defragfns' callbacks are called with a pointer to memory that callback
 * can reallocate. The callbacks should return a new memory address or NULL,
 * where NULL means that no reallocation happened and the old memory is still
 * valid. */
unsigned long dictScanDefrag(dict *d,
                             unsigned long v,
                             dictScanFunction *fn,
                             dictDefragFunctions *defragfns,
                             void *privdata)
{
    int htidx0, htidx1;
    const dictEntry *de, *next;
    unsigned long m0, m1;

    if (dictSize(d) == 0) return 0;

    /* This is needed in case the scan callback tries to do dictFind or alike. */
    dictPauseRehashing(d);	//暂停渐进式hash

    if (!dictIsRehashing(d)) {
        //如果没有进行hash，那么就在第一个表里面
        htidx0 = 0;
        m0 = DICTHT_SIZE_MASK(d->ht_size_exp[htidx0]);//通过指数获取掩码，用于计算桶的索引

        /* Emit entries at cursor */
        if (defragfns) {
            dictDefragBucket(d, &d->ht_table[htidx0][v & m0], defragfns);
        }
        de = d->ht_table[htidx0][v & m0];
        //开始遍历
        while (de) {
            next = dictGetNext(de);
            // 回调调用expireScanCallback()
            fn(privdata, de);
            de = next;
        }

        /* Set unmasked bits so incrementing the reversed cursor
         * operates on the masked bits */
        v |= ~m0;

        /* Increment the reverse cursor */
        v = rev(v);
        v++;
        v = rev(v);

    } else {
        htidx0 = 0;
        htidx1 = 1;

        /* Make sure t0 is the smaller and t1 is the bigger table */
        if (DICTHT_SIZE(d->ht_size_exp[htidx0]) > DICTHT_SIZE(d->ht_size_exp[htidx1])) {
            htidx0 = 1;
            htidx1 = 0;
        }

        m0 = DICTHT_SIZE_MASK(d->ht_size_exp[htidx0]);
        m1 = DICTHT_SIZE_MASK(d->ht_size_exp[htidx1]);

        /* Emit entries at cursor */
        if (defragfns) {
            dictDefragBucket(d, &d->ht_table[htidx0][v & m0], defragfns);
        }
        de = d->ht_table[htidx0][v & m0];
        while (de) {
            next = dictGetNext(de);
            fn(privdata, de);
            de = next;
        }

        /* Iterate over indices in larger table that are the expansion
         * of the index pointed to by the cursor in the smaller table */
        do {
            /* Emit entries at cursor */
            if (defragfns) {
                dictDefragBucket(d, &d->ht_table[htidx1][v & m1], defragfns);
            }
            de = d->ht_table[htidx1][v & m1];
            while (de) {
                next = dictGetNext(de);
                fn(privdata, de);
                de = next;
            }

            /* Increment the reverse cursor not covered by the smaller mask.*/
            v |= ~m1;
            v = rev(v);
            v++;
            v = rev(v);

            /* Continue while bits covered by mask difference is non-zero */
        } while (v & (m0 ^ m1));
    }

    dictResumeRehashing(d);

    return v;
}
// 扫描回调函数
void expireScanCallback(void *privdata, const dictEntry *const_de) {
    dictEntry *de = (dictEntry *)const_de;
    expireScanData *data = privdata;
    long long ttl  = dictGetSignedIntegerVal(de) - data->now;
    //执行删除
    if (activeExpireCycleTryExpire(data->db, de, data->now)) {
        data->expired++;			//计算过期键数量
        /* Propagate the DEL command */
        // 广播del命令给从库
        postExecutionUnitOperations();
    }
    if (ttl > 0) {
        /* We want the average TTL of keys yet not expired. */
        data->ttl_sum += ttl;
        data->ttl_samples++;	// 还没有过期
    }
    data->sampled++;	//检测数量增加
}

int activeExpireCycleTryExpire(redisDb *db, dictEntry *de, long long now) {
    long long t = dictGetSignedIntegerVal(de);	// 从expire表中获取过期时间
    if (now > t) {
        // 如果过期了就删除
        sds key = dictGetKey(de);	// 获取存储的变量名
        robj *keyobj = createStringObject(key,sdslen(key));
        deleteExpiredKeyAndPropagate(db,keyobj);
        decrRefCount(keyobj);
        return 1;
    } else {
        return 0;
    }
}
int64_t dictGetSignedIntegerVal(const dictEntry *de) {
    assert(entryHasValue(de));
    return de->v.s64;
}
/* Delete the specified expired key and propagate expire. */
void deleteExpiredKeyAndPropagate(redisDb *db, robj *keyobj) {
    mstime_t expire_latency;
    latencyStartMonitor(expire_latency);
    dbGenericDelete(db,keyobj,server.lazyfree_lazy_expire,DB_FLAG_KEY_EXPIRED);
    latencyEndMonitor(expire_latency);
    latencyAddSampleIfNeeded("expire-del",expire_latency);
    notifyKeyspaceEvent(NOTIFY_EXPIRED,"expired",keyobj,db->id);
    signalModifiedKey(NULL, db, keyobj);
    propagateDeletion(db,keyobj,server.lazyfree_lazy_expire);
    server.stat_expiredkeys++;
}
//从代码可以看出，对于过期了的键，删除以后仍然会进行计数处理

这段代码是Redis中的主动过期机制（active expire cycle）的实现函数。该函数负责在后台扫描Redis数据库中的键，并删除已过期的键。这个过程是周期性的，它会在每个函数调用中处理多个数据库（CRON_DBS_PER_CALL）。下面是代码的解释：

宏定义部分：
- ACTIVE_EXPIRE_CYCLE_KEYS_PER_LOOP：每次循环中处理的过期键的数量。
- ACTIVE_EXPIRE_CYCLE_FAST_DURATION：快速过期扫描的最长执行时间（以微秒为单位）。
- ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC：每次循环允许使用的最大CPU时间百分比。
- ACTIVE_EXPIRE_CYCLE_ACCEPTABLE_STALE：每个周期内允许的过期键百分比，如果某个数据库的过期键超过这个百分比，那么该数据库会被重新处理。
activeExpireCycle函数：
- type参数表示执行的类型，可以是ACTIVE_EXPIRE_CYCLE_FAST（快速过期扫描）或其他值（正常扫描）。
- 通过调整运行参数，根据配置的过期努力程度来控制过期键的处理：
  - effort：根据配置的努力程度调整运行参数。默认努力程度为1，最大可配置努力程度为10。
  - config_keys_per_loop：每次循环中处理的过期键的数量。随着努力程度的增加，处理的过期键数量也会增加。
  - config_cycle_fast_duration：每次快速过期扫描的最长执行时间。随着努力程度的增加，最长执行时间也会增加。
  - config_cycle_slow_time_perc：每次循环允许使用的最大CPU时间百分比。随着努力程度的增加，允许的CPU时间百分比也会增加。
  - config_cycle_acceptable_stale：每个周期内允许的过期键百分比。随着努力程度的增加，允许的过期键百分比会减少。
- 函数内部有一些全局状态变量，用于在多次调用之间继续工作。
- 首先，检查是否有针对"expire"操作的暂停（pause）标志。如果有暂停，则不会处理任何过期键。
- 快速过期扫描：
  - 通过一些条件判断，决定是否执行快速过期扫描。
  - 如果上一次的快速扫描没有因为时间限制而退出，并且预估的过期键百分比较小，则不会执行快速扫描。
- 循环处理数据库：
  - 对多个数据库执行循环，直到处理了所有配置的数据库或达到了时间限制。
  - dbs_per_call：每次循环处理的数据库数目，不能超过实际数据库数目。如果上一次运行达到了时间限制，则会在这次迭代中处理所有数据库。
  - 根据配置，计算每次循环最多允许的执行时间timelimit。
  - 如果是快速过期扫描，那么执行时间限制为预设的config_cycle_fast_duration。
  - 统计全局的过期键状态，以了解已经过期但仍存在于数据库中的键的数量。
  - 对每个数据库进行过期扫描：
    - 按照一定的规则选择一些键进行检查。
    - 在过期键中进行随机抽查，并检查是否过期。
    - 更新全局的过期键状态。
    - 在超过时间限制时退出循环，等待下一次调用。

这段代码实现了Redis数据库中的过期键处理机制，通过不同的努力程度和配置参数来控制过期键的处理方式。不同的配置可以在运行时调整过期键处理的速度和性能。

定期删除如何选择进行快速过期扫描还是普通扫描呢？

我们还是来看源码

c 复制代码

void databasesCron(void) {
    /* Expire keys by random sampling. Not required for slaves
     * as master will synthesize DELs for us. */
    if (server.active_expire_enabled) {
        if (iAmMaster()) {
            activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW);
        } else {
            expireSlaveKeys();
        }
    }
    ......
}

c 复制代码

/* This function gets called every time Redis is entering the
 * main loop of the event driven library, that is, before to sleep
 * for ready file descriptors.
 *
 * Note: This function is (currently) called from two functions:
 * 1. aeMain - The main server loop
 * 2. processEventsWhileBlocked - Process clients during RDB/AOF load
 *
 * If it was called from processEventsWhileBlocked we don't want
 * to perform all actions (For example, we don't want to expire
 * keys), but we do need to perform some actions.
 *
 * The most important is freeClientsInAsyncFreeQueue but we also
 * call some other low-risk functions. */
void beforeSleep(struct aeEventLoop *eventLoop) {
    ......
    if (server.active_expire_enabled && iAmMaster())
        activeExpireCycle(ACTIVE_EXPIRE_CYCLE_FAST);
    ......
}

一般情况下，都是用的普通扫描，beforeSleep（貌似是Redis事件里面的了）用的快速扫描