>  기사  >  데이터 베이스  >  Redis의 만료 작업 및 만료 전략에 대해 설명하는 기사

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

青灯夜游
青灯夜游앞으로
2022-02-09 10:12:372542검색

이 기사에서는 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 文件写入

RedisAOF 模式持久化时,如果数据库某个过期键还没被删除,那么 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 &#39;id&#39; 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>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>는 AOF 모드가 지속되는 경우 데이터베이스의 만료된 키가 삭제되지 않은 경우 AOF 파일은 만료된 키를 유지합니다. 키가 삭제되면 RedisAOF 파일에 DEL 명령을 추가하여 키 값을 명시적으로 삭제합니다. 🎜🎜🎜2. AOF 재작성🎜🎜🎜AOF 재작성을 수행할 때 Redi의 키-값 쌍은 확인되지 않습니다. AOF 파일을 다시 작성하므로 AOF 다시 작성에 영향을 주지 않습니다. 🎜🎜🎜🎜마스터-슬레이브 라이브러리의 키가 만료되었습니다🎜🎜🎜

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

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

过期策略

Redis 中我们可以给一些元素设置过期时间,那当它过期之后 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 &#39;id&#39; 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 高负载的情况下或有大量过期键需要同时处理时,会造成 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의 만료 작업 및 만료 전략에 대해 설명하는 기사

定期删除

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

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

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

定期删除流程

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

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

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

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

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

  • 优点:通过限制删除操作的时长和频率,来减少删除操作对 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 중국어 웹사이트의 기타 관련 기사를 참조하세요!

성명:
이 기사는 juejin.cn에서 복제됩니다. 침해가 있는 경우 admin@php.cn으로 문의하시기 바랍니다. 삭제