Redis의 만료 작업 및 만료 전략에 대해 설명하는 기사

이 기사에서는 Redis의 만료 작업 및 만료 전략을 안내하고 Redis에서 만료 시간을 설정하는 네 가지 방법, 지속성에서 만료된 키, 만료된 키 실행 프로세스 등을 소개합니다. 도움이 되길 바랍니다!

Redis에 만료 개념이 없다면 이는 우리가 작성한 모든 키가 활성화되지 않는 한 항상 Redis에 저장된다는 의미입니다. 삭제되었습니다. 그리고 Redis는 메모리 기반 데이터베이스이므로 메모리 공간이 매우 제한되어 있습니다. [관련 권장사항: Redis 동영상 튜토리얼]Redis 中没有过期这个概念，这就意味着我们所有写入的键只要不主动删除就会一直保存在 Redis 中，而 Redis 又是一个基于内存的数据库，内存空间是非常有限的。【相关推荐：Redis视频教程】

过期操作

过期设置

Redis 中设置过期时间主要通过以下四种方式：

• expire key seconds：设置 key 在 n 秒后过期。
• pexpire key milliseconds：设置 key 在 n 毫秒后过期。
• expireat key timestamp：设置 key 在某个时间戳（精确到秒）之后过期。
• pexpireat key millisecondsTimestamp：设置 key 在某个时间戳（精确到毫秒）之后过期。

可用命令 ttl key （以秒为单位）或 pttl key （以毫秒为单位）来查看 key 还有多久过期。

Redis 可以使用 time 命令查询当前时间的时间戳（精确到秒）。

字符串中几个直接操作过期时间的方法，如下列表：

• set key value ex seconds：设置键值对的同时指定过期时间（精确到秒）。
• set key value px milliseconds：设置键值对的同时指定过期时间（精确到毫秒）。
• setex key seconds valule：设置键值对的同时指定过期时间（精确到秒）。

移除过期时间

使用命令： persist key 可以移除键值的过期时间。-1 表示永不过期。

Java 实现过期操作

使用 Jedis 来实现对 Redis 的操作，代码：

public class TTLTest {
    public static void main(String[] args) throws InterruptedException {
        // 创建 Redis 连接
        Jedis jedis = new Jedis("xxx.xxx.xxx.xxx", 6379);
        // 设置 Redis 密码(如果没有密码，此行可省略)
        jedis.auth("xxx");
        // 存储键值对（默认情况下永不过期）
        jedis.set("k", "v");
        // 查询 TTL（过期时间）
        Long ttl = jedis.ttl("k");
        // 打印过期日志
        // 过期时间：-1
        System.out.println("过期时间：" + ttl);
        // 设置 100s 后过期
        jedis.expire("k", 100);
        // 等待 1s 后执行
        Thread.sleep(1000);
        // 打印过期日志
        // 执行 expire 后的 TTL=99
        System.out.println("执行 expire 后的 TTL=" + jedis.ttl("k"));
    }
}

更多过期操作方法，如下列表：

• pexpire(String key, long milliseconds)：设置 n 毫秒后过期。
• expireAt(String key, long unixTime)：设置某个时间戳后过期（精确到秒）。
• pexpireAt(String key, long millisecondsTimestamp)：设置某个时间戳后过期（精确到毫秒）。
• persist(String key)：移除过期时间。

public class TTLTest {
    public static void main(String[] args) throws InterruptedException {
        // 创建 Redis 连接
        Jedis jedis = new Jedis("xxx.xxx.xxx.xxx", 6379);
        // 设置 Redis 密码(如果没有密码，此行可省略)
        jedis.auth("xxx");
        // 存储键值对（默认情况下永不过期）
        jedis.set("k", "v");
        // 查询 TTL（过期时间）
        Long ttl = jedis.ttl("k");
        // 打印过期日志
        System.out.println("过期时间：" + ttl);
        // 设置 100s 后过期
        jedis.expire("k", 100);
        // 等待 1s 后执行
        Thread.sleep(1000);
        // 打印过期日志
        System.out.println("执行 expire 后的 TTL=" + jedis.ttl("k"));
        // 设置 n 毫秒后过期
        jedis.pexpire("k", 100000);
        // 设置某个时间戳后过期（精确到秒）
        jedis.expireAt("k", 1573468990);
        // 设置某个时间戳后过期（精确到毫秒）
        jedis.pexpireAt("k", 1573468990000L);
        // 移除过期时间
        jedis.persist("k");
    }
}

持久化中的过期键

RDB 中的过期键

RDB 文件分为两个阶段，RDB 文件生成阶段和加载阶段。

1. RDB 文件生成

RDB 加载分为以下两种情况：

• 如果 Redis 是主服务器运行模式的话，在载入 RDB 文件时，程序会对文件中保存的键进行检查，过期键不会被载入到数据库中。所以过期键不会对载入 RDB 文件的主服务器造成影响；
• 如果 Redis 是从服务器运行模式的话，在载入 RDB 文件时，不论键是否过期都会被载入到数据库中。但由于主从服务器在进行数据同步时，从服务器的数据会被清空。所以一般来说，过期键对载入 RDB 文件的从服务器也不会造成影响。

RDB 文件加载的源码可以在 rdb.c 文件的 rdbLoad() 函数中找到，源码所示：

/* Check if the key already expired. This function is used when loading
* an RDB file from disk, either at startup, or when an RDB was
* received from the master. In the latter case, the master is
* responsible for key expiry. If we would expire keys here, the
* snapshot taken by the master may not be reflected on the slave. 
*
* 如果服务器为主节点的话，
* 那么在键已经过期的时候，不再将它们关联到数据库中去
*/
if (server.masterhost == NULL && expiretime != -1 && expiretime < now) {
    decrRefCount(key);
    decrRefCount(val);
    // 跳过
    continue;
}

AOF 中的过期键

1. AOF 文件写入

当 Redis 以 AOF 模式持久化时，如果数据库某个过期键还没被删除，那么 AOF 文件会保留此过期键，当此过期键被删除后，Redis 会向 AOF 文件追加一条 DEL 命令来显式地删除该键值。

2. AOF 重写

执行 AOF 重写时，会对 Redis 中的键值对进行检查已过期的键不会被保存到重写后的 AOF 文件中，因此不会对 AOF

만료 작업

만료 설정

Redis 만료 시간을 설정하는 방법은 주로 네 가지가 있습니다: 🎜

• expire 키 초: 키가 n초 후에 만료되도록 설정합니다.
• pexpire key milliseconds: key가 n 밀리초 후에 만료되도록 설정합니다.
• 만료 키 타임스탬프: 특정 타임스탬프(정확하게 초 단위) 후에 만료되도록 키를 설정합니다.
• pexpireat key millisecondsTimestamp: 특정 타임스탬프(정확하게는 밀리초) 후에 만료되도록 키를 설정합니다.

🎜ttl key(초 단위) 또는 pttl key(밀리초 단위) 명령을 사용하여 key 방법을 볼 수 있습니다. code>가 만료되는 데 시간이 오래 걸립니다. 🎜🎜Redis time 명령을 사용하여 현재 시간의 타임스탬프(초 단위)를 쿼리할 수 있습니다. 🎜🎜다음과 같이 문자열에서 만료 시간을 직접 연산하는 여러 가지 방법: 🎜

• 초 단위로 키 값 설정: 키 값 쌍을 설정하고 만료 시간을 지정합니다(정확한 초) ).
• 키 값 px 밀리초 설정: 키 값 쌍을 설정하고 만료 시간을 지정합니다(정확한 밀리초).
• setex 키 초 값: 키-값 쌍을 설정하고 만료 시간(초 단위)을 지정합니다.

🎜🎜🎜만료 시간 제거🎜🎜🎜🎜키 값의 만료 시간을 제거하려면 persist key 명령을 사용하세요. -1은 만료되지 않음을 의미합니다. 🎜🎜🎜🎜Java는 만료 작업을 구현합니다🎜🎜🎜🎜Jedis를 사용하여 Redis에서 작업을 구현합니다. 코드: 🎜

/* 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. */
typedef struct redisDb {
    dict *dict;                 /* 数据库键空间，存放着所有的键值对 */
    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;                     /* Database ID */
    long long avg_ttl;          /* Average TTL, just for stats */
    list *defrag_later;         /* List of key names to attempt to defrag one by one, gradually. */
} redisDb;

🎜🎜아래 나열된 추가 만료 작업 방법🎜 ： 🎜

• pexpire(String key, long milliseconds): n 밀리초 후에 만료되도록 설정합니다.
• expireAt(String key, long unixTime): 특정 타임스탬프(초 단위)를 설정한 후 만료됩니다.
• pexpireAt(String key, long millisecondsTimestamp): 특정 타임스탬프(정확도는 밀리초)를 설정한 후 만료됩니다.
• persist(String key): 만료 시간을 제거합니다.

int expireIfNeeded(redisDb *db, robj *key) {
    // 判断键是否过期
    if (!keyIsExpired(db,key)) return 0;
    if (server.masterhost != NULL) return 1;
    /* 删除过期键 */
    // 增加过期键个数
    server.stat_expiredkeys++;
    // 传播键过期的消息
    propagateExpire(db,key,server.lazyfree_lazy_expire);
    notifyKeyspaceEvent(NOTIFY_EXPIRED,
        "expired",key,db->id);
    // server.lazyfree_lazy_expire 为 1 表示异步删除（懒空间释放），反之同步删除
    return server.lazyfree_lazy_expire ? dbAsyncDelete(db,key) :
                                         dbSyncDelete(db,key);
}
// 判断键是否过期
int keyIsExpired(redisDb *db, robj *key) {
    mstime_t when = getExpire(db,key);
    if (when < 0) return 0; /* No expire for this key */
    /* Don&#39;t expire anything while loading. It will be done later. */
    if (server.loading) return 0;
    mstime_t now = server.lua_caller ? server.lua_time_start : mstime();
    return now > when;
}
// 获取键的过期时间
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;
    /* 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);
}

🎜🎜🎜지속성의 만료된 키🎜🎜🎜

🎜RDB의 만료된 키🎜

🎜RDB< /code > 파일은 <code>RDB 파일 생성 단계와 로딩 단계의 두 단계로 나누어집니다. 🎜🎜🎜1.RDB 파일 생성🎜🎜🎜RDB 로딩은 다음 두 가지 상황으로 나누어집니다. 🎜

• Redis가 🎜main🎜서버인 경우 작동 모드 그렇다면 RDB 파일을 로드할 때 프로그램은 파일에 저장된 키를 확인하고 만료된 키는 데이터베이스에 로드되지 않습니다. 따라서 만료된 키는 RDB 파일을 로드하는 기본 서버에 영향을 미치지 않습니다.
• Redis가 🎜slave🎜서버 실행 모드인 경우, 로드 RDB 파일을 로드할 때 키는 만료 여부에 관계없이 데이터베이스에 로드됩니다. 하지만🎜마스터 서버와 슬레이브 서버가 데이터를 동기화하는 동안 슬레이브 서버의 데이터는 삭제됩니다🎜. 따라서 일반적으로 만료된 키는 RDB 파일을 로드하는 슬레이브 서버에 영향을 미치지 않습니다.

🎜RDB 파일을 로드하기 위한 소스 코드는 rdb.c</의 <code>rdbLoad() 함수에서 찾을 수 있습니다. code> 파일 표시: 🎜

void activeExpireCycle(int type) {
    static unsigned int current_db = 0; /* 上次定期删除遍历到的数据库ID */
    static int timelimit_exit = 0;      /* Time limit hit in previous call? */
    static long long last_fast_cycle = 0; /* 上一次执行快速定期删除的时间点 */
    int j, iteration = 0;
    int dbs_per_call = CRON_DBS_PER_CALL; // 每次定期删除，遍历的数据库的数量
    long long start = ustime(), timelimit, elapsed;
    if (clientsArePaused()) return;
    if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
        if (!timelimit_exit) return;
        // ACTIVE_EXPIRE_CYCLE_FAST_DURATION 是快速定期删除的执行时长
        if (start < last_fast_cycle + ACTIVE_EXPIRE_CYCLE_FAST_DURATION*2) return;
        last_fast_cycle = start;
    }
    if (dbs_per_call > server.dbnum || timelimit_exit)
        dbs_per_call = server.dbnum;
    // 慢速定期删除的执行时长
    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; /* 删除操作的执行时长 */
    long total_sampled = 0;
    long total_expired = 0;
    for (j = 0; j < dbs_per_call && timelimit_exit == 0; j++) {
        int expired;
        redisDb *db = server.db+(current_db % server.dbnum);
        current_db++;
        do {
            // .......
            expired = 0;
            ttl_sum = 0;
            ttl_samples = 0;
            // 每个数据库中检查的键的数量
            if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
                num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;
            // 从数据库中随机选取 num 个键进行检查
            while (num--) {
                dictEntry *de;
                long long ttl;
                if ((de = dictGetRandomKey(db->expires)) == NULL) break;
                ttl = dictGetSignedInteger
                // 过期检查，并对过期键进行删除
                if (activeExpireCycleTryExpire(db,de,now)) expired++;
                if (ttl > 0) {
                    /* We want the average TTL of keys yet not expired. */
                    ttl_sum += ttl;
                    ttl_samples++;
                }
                total_sampled++;
            }
            total_expired += expired;
            if (ttl_samples) {
                long long avg_ttl = ttl_sum/ttl_samples;
                if (db->avg_ttl == 0) db->avg_ttl = avg_ttl;
                db->avg_ttl = (db->avg_ttl/50)*49 + (avg_ttl/50);
            }
            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;
                }
            }
            /* 每次检查只删除 ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4 个过期键 */
        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);
    }
    // .......
}

🎜AOF🎜

🎜🎜1의 만료된 키🎜🎜🎜Redis</ code>는 < code>AOF 모드가 지속되는 경우 데이터베이스의 만료된 키가 삭제되지 않은 경우 AOF 파일은 만료된 키를 유지합니다. 키가 삭제되면 Redis는 AOF 파일에 DEL 명령을 추가하여 키 값을 명시적으로 삭제합니다. 🎜🎜🎜2. AOF 재작성🎜🎜🎜AOF 재작성을 수행할 때 Redi의 키-값 쌍은 확인되지 않습니다. AOF 파일을 다시 작성하므로 AOF 다시 작성에 영향을 주지 않습니다. 🎜🎜🎜🎜마스터-슬레이브 라이브러리의 키가 만료되었습니다🎜🎜🎜

当 Redis 运行在主从模式下时，从库不会进行过期扫描，从库对过期的处理是被动的。也就是即使从库中的 key 过期了，如果有客户端访问从库时，依然可以得到 key 对应的值，像未过期的键值对一样返回。

从库的过期键处理依靠主服务器控制，主库在 key 到期时，会在 AOF 文件里增加一条 del 指令，同步到所有的从库，从库通过执行这条 del 指令来删除过期的 key。

过期策略

在 Redis 中我们可以给一些元素设置过期时间，那当它过期之后 Redis 是如何处理这些过期键呢？

过期键执行流程

Redis 之所以能知道那些键值过期，是因为在 Redis 中维护了一个字典，存储了所有设置了过期时间的键值，我们称之为过期字典。

过期键源码分析

过期键存储在 redisDb 结构中，源代码在 src/server.h 文件中（基于 Redis 5）：

/* 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. */
typedef struct redisDb {
    dict *dict;                 /* 数据库键空间，存放着所有的键值对 */
    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;                     /* Database ID */
    long long avg_ttl;          /* Average TTL, just for stats */
    list *defrag_later;         /* List of key names to attempt to defrag one by one, gradually. */
} redisDb;

过期键数据结构如下图所示：

过期策略

Redis 会删除已过期的键值，以此来减少 Redis 的空间占用，但因为 Redis 本身是单线的，如果因为删除操作而影响主业务的执行就得不偿失了，为此 Redis 需要制定多个（过期）删除策略来保证正常执行的性能。

定时删除

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

• 优点：保证内存可以被尽快地释放。
• 缺点：在 Redis 高负载的情况下或有大量过期键需要同时处理时，会造成 Redis 服务器卡顿，影响主业务执行。

惰性删除

不主动删除过期键，每次从数据库获取键值时判断是否过期，如果过期则删除键值，并返回 null。

• 优点：因为每次访问时，才会判断过期键，所以此策略只会使用很少的系统资源。
• 缺点：系统占用空间删除不及时，导致空间利用率降低，造成了一定的空间浪费。

源码解析

惰性删除的源码位于 src/db.c 文件的 expireIfNeeded 方法中，源码如下：

int expireIfNeeded(redisDb *db, robj *key) {
    // 判断键是否过期
    if (!keyIsExpired(db,key)) return 0;
    if (server.masterhost != NULL) return 1;
    /* 删除过期键 */
    // 增加过期键个数
    server.stat_expiredkeys++;
    // 传播键过期的消息
    propagateExpire(db,key,server.lazyfree_lazy_expire);
    notifyKeyspaceEvent(NOTIFY_EXPIRED,
        "expired",key,db->id);
    // server.lazyfree_lazy_expire 为 1 表示异步删除（懒空间释放），反之同步删除
    return server.lazyfree_lazy_expire ? dbAsyncDelete(db,key) :
                                         dbSyncDelete(db,key);
}
// 判断键是否过期
int keyIsExpired(redisDb *db, robj *key) {
    mstime_t when = getExpire(db,key);
    if (when < 0) return 0; /* No expire for this key */
    /* Don&#39;t expire anything while loading. It will be done later. */
    if (server.loading) return 0;
    mstime_t now = server.lua_caller ? server.lua_time_start : mstime();
    return now > when;
}
// 获取键的过期时间
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;
    /* 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);
}

所有对数据库的读写命令在执行之前，都会调用 expireIfNeeded 方法判断键值是否过期，过期则会从数据库中删除，反之则不做任何处理。

定期删除

每隔一段时间检查一次数据库，随机删除一些过期键。

Redis 默认每秒进行 10 次过期扫描，此配置可通过 Redis 的配置文件 redis.conf 进行配置，配置键为 hz 它的默认值是 hz 10。

注意：Redis 每次扫描并不是遍历过期字典中的所有键，而是采用随机抽取判断并删除过期键的形式执行的。

定期删除流程

• 从过期字典中随机取出 20 个键。

• 删除这 20 个键中过期的键。

• 如果过期 key 的比例超过 25%，重复步骤 1。

同时为了保证过期扫描不会出现循环过度，导致线程卡死现象，算法还增加了扫描时间的上限，默认不会超过 25ms。

• 优点：通过限制删除操作的时长和频率，来减少删除操作对 Redis 主业务的影响，同时也能删除一部分过期的数据减少了过期键对空间的无效占用。
• 缺点：内存清理方面没有定时删除效果好，同时没有惰性删除使用的系统资源少。

源码解析

定期删除的核心源码在 src/expire.c 文件下的 activeExpireCycle 方法中，源码如下：

void activeExpireCycle(int type) {
    static unsigned int current_db = 0; /* 上次定期删除遍历到的数据库ID */
    static int timelimit_exit = 0;      /* Time limit hit in previous call? */
    static long long last_fast_cycle = 0; /* 上一次执行快速定期删除的时间点 */
    int j, iteration = 0;
    int dbs_per_call = CRON_DBS_PER_CALL; // 每次定期删除，遍历的数据库的数量
    long long start = ustime(), timelimit, elapsed;
    if (clientsArePaused()) return;
    if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
        if (!timelimit_exit) return;
        // ACTIVE_EXPIRE_CYCLE_FAST_DURATION 是快速定期删除的执行时长
        if (start < last_fast_cycle + ACTIVE_EXPIRE_CYCLE_FAST_DURATION*2) return;
        last_fast_cycle = start;
    }
    if (dbs_per_call > server.dbnum || timelimit_exit)
        dbs_per_call = server.dbnum;
    // 慢速定期删除的执行时长
    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; /* 删除操作的执行时长 */
    long total_sampled = 0;
    long total_expired = 0;
    for (j = 0; j < dbs_per_call && timelimit_exit == 0; j++) {
        int expired;
        redisDb *db = server.db+(current_db % server.dbnum);
        current_db++;
        do {
            // .......
            expired = 0;
            ttl_sum = 0;
            ttl_samples = 0;
            // 每个数据库中检查的键的数量
            if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
                num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;
            // 从数据库中随机选取 num 个键进行检查
            while (num--) {
                dictEntry *de;
                long long ttl;
                if ((de = dictGetRandomKey(db->expires)) == NULL) break;
                ttl = dictGetSignedInteger
                // 过期检查，并对过期键进行删除
                if (activeExpireCycleTryExpire(db,de,now)) expired++;
                if (ttl > 0) {
                    /* We want the average TTL of keys yet not expired. */
                    ttl_sum += ttl;
                    ttl_samples++;
                }
                total_sampled++;
            }
            total_expired += expired;
            if (ttl_samples) {
                long long avg_ttl = ttl_sum/ttl_samples;
                if (db->avg_ttl == 0) db->avg_ttl = avg_ttl;
                db->avg_ttl = (db->avg_ttl/50)*49 + (avg_ttl/50);
            }
            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;
                }
            }
            /* 每次检查只删除 ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4 个过期键 */
        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);
    }
    // .......
}

activeExpireCycle 方法在规定的时间，分多次遍历各个数据库，从过期字典中随机检查一部分过期键的过期时间，删除其中的过期键。

这个函数有两种执行模式，一个是快速模式一个是慢速模式，体现是代码中的 timelimit 变量，这个变量是用来约束此函数的运行时间的。快速模式下 timelimit 的值是固定的，等于预定义常量 ACTIVE_EXPIRE_CYCLE_FAST_DURATION，慢速模式下，这个变量的值是通过 1000000 * ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100 计算的。

Redis 使用的过期策略

Redis 使用的是惰性删除加定期删除的过期策略。

更多编程相关知识，请访问：编程入门！！

위 내용은 Redis의 만료 작업 및 만료 전략에 대해 설명하는 기사의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!