Redis での有効期限操作と有効期限戦略について説明する記事

この記事では、Redis の有効期限操作と有効期限戦略を理解し、Redis で有効期限を設定する 4 つの方法、永続化での期限切れキー、期限切れキーの実行プロセスなどを紹介します。皆様のお役に立てれば幸いです。 . !

Redis に有効期限の概念がない場合、作成したすべてのキーは、有効である限り常に # に保存されることを意味します。 ##Redis および Redis はメモリベースのデータベースであり、メモリ空間は非常に限られています。 [関連する推奨事項: Redis ビデオ チュートリアル ]

期限切れ操作

期限切れ設定

#Redis で有効期限を設定するには主に 4 つの方法があります:

• expire key minutes: key を n 秒後に期限切れに設定します。
• pexpire key ミリ秒: key を n ミリ秒で期限切れになるように設定します。
• expireat key timestamp: key を特定のタイムスタンプ (秒単位の精度) 後に期限切れになるように設定します。
• pexpireat key millisecondsTimestamp: key を特定のタイムスタンプ (ミリ秒単位の精度) 後に期限切れになるように設定します。

コマンド

ttl key (秒単位) または pttl key (ミリ秒単位) を使用して、key を表示できます。有効期限が切れるまでに時間がかかります。

Redis time コマンドを使用して、現在の時刻 (秒単位の精度) のタイムスタンプをクエリできます。

以下に示すように、文字列で有効期限を直接操作するためのいくつかのメソッド:

• set key value ex 秒: キーと値のペアを設定し、有効期限を指定します。同じ時刻 時刻 (秒単位の精度)。
• 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

ファイルは 2 つの段階に分かれています。RDB ファイル生成段階と読み込み段階です。

1. RDB ファイルの生成

RDB

ロードは次の 2 つの状況に分かれます。 # #Redis が main

サーバー動作モードの場合、

RDB
• ファイルをロードするときに、プログラムはファイルに保存されているキーをチェックし、期限切れのキーはロードされませんデータベースに入れます。したがって、期限切れのキーは、RDB ファイルをロードするメイン サーバーには影響しません。#Redis が スレーブ サーバー モードで実行されている場合、
RDB
• ファイルをロードすると、キーの有効期限が切れているかどうかに関係なく、キーがデータベースにロードされます。ただし、マスターサーバーとスレーブサーバーがデータ同期を実行すると、スレーブサーバーのデータは消去されます。したがって、一般的に言えば、期限切れのキーは RDB ファイルをロードするスレーブ サーバーには影響しません。 RDB ファイル読み込みのソース コードは、rdb.c
ファイルの

rdbLoad()

関数にあります。 <pre class='brush:php;toolbar:false;'>/* 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 &amp;&amp; expiretime != -1 &amp;&amp; expiretime &lt; now) { decrRefCount(key); decrRefCount(val); // 跳过 continue; }</pre>AOF のキーが期限切れになりました

1. AOF ファイルの書き込み

When

Redis

は AOF で始まります モードが永続化されている場合、データベース内の期限切れのキーが削除されていない場合、

AOF

ファイルには期限切れのキーが保持されます。キーが削除されました。 Redis DEL コマンドが AOF ファイルに追加され、キー値を明示的に削除します。 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 中国語 Web サイトの他の関連記事を参照してください。