Redis系列（三）--过期策略

制定Redis过期策略，是整个Redis缓存策略的关键之一，因为内存来说，公司不可能无限大，所以就要对key进行一系列的管控。

文章结构：

（1）理解Redis过期设置API（命令与Java描述版本）；
（2）理解Redis内部的过期策略；
（3）对开发需求而言，Redis过期策略的设计实现经验。

---

本系列文章：

（1） Redis系列（一）–安装、helloworld以及读懂配置文件

（2）Redis系列（二）–缓存设计（整表缓存以及排行榜缓存方案实现）

一、理解Redis过期设置API（命令与Java描述版本）：

（1）TTL命令：

redis 127.0.0.1:6379> TTL KEY_NAME

返回值

当 key 不存在时，返回 -2 。 当 key 存在但没有设置剩余生存时间时，返回 -1 。 否则，以秒为单位，返回 key 的剩余生存时间。
注意：在 Redis 2.8 以前，当 key 不存在，或者 key 没有设置剩余生存时间时，命令都返回 -1 。

（2）EXPIRE命令

定义：为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。

redis 127.0.0.1:6379> EXPIRE runooobkey 60
(integer) 1

返回值

设置成功返回 1 。 当 key 不存在或者不能为 key 设置过期时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的过期时间)返回 0 。

key生存时间注意点：

生存时间可以通过使用 DEL 命令来删除整个 key 来移除，或者被 SET 和 GETSET 命令覆写(overwrite)，这意味着，如果一个命令只是修改(alter)一个带生存时间的 key 的值而不是用一个新的 key 值来代替(replace)它的话，那么生存时间不会被改变。

比如说，对一个 key 执行 INCR 命令，对一个列表进行 LPUSH 命令，或者对一个哈希表执行 HSET 命令，这类操作都不会修改 key 本身的生存时间。

另一方面，如果使用 RENAME 对一个 key 进行改名，那么改名后的 key 的生存时间和改名前一样。

RENAME 命令的另一种可能是，尝试将一个带生存时间的 key 改名成另一个带生存时间的 another_key ，这时旧的 another_key (以及它的生存时间)会被删除，然后旧的 key 会改名为 another_key ，因此，新的 another_key 的生存时间也和原本的 key 一样。

（3）PEXPIRE命令

设置成功返回 1 。 当 key 不存在或者不能为 key 设置过期时间时(比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的过期时间)返回 0 。

（4）PERSIST 命令

返回值：
当过期时间移除成功时，返回 1 。 如果 key 不存在或 key 没有设置过期时间，返回 0 。

127.0.0.1:6379> PEXPIRE k2 10000000
(integer) 1

（5）SETEX命令

用于在Redis键中的指定超时，设置键的字符串值

返回值：

字符串，如果在键中设置了值则返回OK。如果值未设置则返回 Null。

127.0.0.1:6379> SETEX k1 100 v1
OK
127.0.0.1:6379> ttl k1
(integer) 92
127.0.0.1:6379> get k1
"v1"

（6）补充：（精度不同的时间设置）：

EXPIREAT < timestamp> 命令用于将键key 的过期时间设置为timestamp所指定的秒数时间戳。

PEXPIREAT < timestamp > 命令用于将键key 的过期时间设置为timestamp所指定的毫秒数时间戳。

例子：

	//TTL命令
127.0.0.1:6379> FLUSHDB
OK
127.0.0.1:6379> ttl key
(integer) -2
127.0.0.1:6379> set key value
OK
127.0.0.1:6379> ttl key
(integer) -1


//expire命令
127.0.0.1:6379> expire key 10
(integer) 1
127.0.0.1:6379> ttl key
(integer) 7
127.0.0.1:6379> ttl key
(integer) 3
127.0.0.1:6379> ttl key
(integer) -2


//PEXPIRE命令
127.0.0.1:6379> set k2 v2
OK
127.0.0.1:6379> PEXPIRE k2 10000000
(integer) 1
127.0.0.1:6379> ttl k2
(integer) 9994


//PERSIST 命令
127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> EXPIRE k1 100
(integer) 1
127.0.0.1:6379> ttl k1
(integer) 86
127.0.0.1:6379> PERSIST k1
(integer) 1
127.0.0.1:6379> ttl k1
(integer) -1

（6）Java代码控制：

    @Autowired
    private JedisPool jedisPool;
	Jedis jedis = jedisPool.getResource();

		System.out.println("判断key是否存在："+shardedJedis.exists("key"));
        // 设置 key001的过期时间
        System.out.println("设置 key的过期时间为5秒:"+jedis.expire("key", 5));
          // 查看某个key的剩余生存时间,单位【秒】.永久生存或者不存在的都返回-1
        System.out.println("查看key的剩余生存时间："+jedis.ttl("key"));
        // 移除某个key的生存时间
        System.out.println("移除key的生存时间："+jedis.persist("key"));
        System.out.println("查看key的剩余生存时间："+jedis.ttl("key"));
        // 查看key所储存的值的类型
        System.out.println("查看key所储存的值的类型："+jedis.type("key"));

---

二、理解Redis内部的过期策略：

（1）总述：

Redis采用的是定期删除策略和懒汉式的策略互相配合。

注意！是Redis内部自主完成！是Redis内部自主完成！是Redis内部自主完成！

我们只可以通过调整外围参数，以及设计数据淘汰模式去调控我们的Redis缓存系统过期策略。

（2）定期删除策略：

1）含义：每隔一段时间执行一次删除过期key操作

2）优点：

通过限制删除操作的时长和频率，来减少删除操作对CPU时间的占用–处理"定时删除"的缺点
定期删除过期key–处理"懒汉式删除"的缺点

3）缺点：

在内存友好方面，会造成一定的内存占用，但是没有懒汉式那么占用内存（相对于定时删除则不如）
在CPU时间友好方面，不如"懒汉式删除"（会定期的去进行比较和删除操作，cpu方面不如懒汉式，但是比定时好）

4）关键点：

合理设置删除操作的执行时长（每次删除执行多长时间）和执行频率（每隔多长时间做一次删除）（这个要根据服务器运行情况来定了），每次执行时间太长，或者执行频率太高对cpu都是一种压力。

每次进行定期删除操作执行之后，需要记录遍历循环到了哪个标志位，以便下一次定期时间来时，从上次位置开始进行循环遍历。

对于懒汉式删除而言，并不是只有获取key的时候才会检查key是否过期，在某些设置key的方法上也会检查（例子：setnx key2 value2：如果设置的key2已经存在，那么该方法返回false，什么都不做；如果设置的key2不存在，那么该方法设置缓存key2-value2。假设调用此方法的时候，发现redis中已经存在了key2，但是该key2已经过期了，如果此时不执行删除操作的话，setnx方法将会直接返回false，也就是说此时并没有重新设置key2-value2成功，所以对于一定要在setnx执行之前，对key2进行过期检查）。

5）删除键流程（简单而言，对指定个数个库的每一个库随机删除小于等于指定个数个过期key）：

1. 遍历每个数据库（就是redis.conf中配置的"database"数量，默认为16）

2. 检查当前库中的指定个数个key（默认是每个库检查20个key，注意相当于该循环执行20次，循环体是下边的描述）

如果当前库中没有一个key设置了过期时间，直接执行下一个库的遍历

随机获取一个设置了过期时间的key，检查该key是否过期，如果过期，删除key

判断定期删除操作是否已经达到指定时长，若已经达到，直接退出定期删除。

对于定期删除，在程序中有一个全局变量current_db来记录下一个将要遍历的库，假设有16个库，我们这一次定期删除遍历了10个，那此时的current_db就是11，下一次定期删除就从第11个库开始遍历，假设current_db等于15了，那么之后遍历就再从0号库开始（此时current_db==0）

6）源码机制阅读：

定期删除策略：此部分转载部分此博主此文章

在redis源码中，实现定期淘汰策略的是函数activeExpireCycle，每当周期性函数serverCron执行时，该函数会调用databasesCron函数;然后databasesCron会调用activeExpireCycle函数进行主动的过期键删除。具体方法是在规定的时间内，多次从expires中随机挑一个键，检查它是否过期，如果过期则删除。

首先这个函数有两种执行模式，一个是快速模式一个是慢速模式，体现在代码中就是timelimit这个变量中，这个变量是用来约束这个函数的运行时间的，我们可以考虑这样一个场景，就是数据库中有很多过期的键需要清理，那么这个函数就会一直运行很长时间，这样一直占用CPU显然是不合理的，所以需要这个变量来约束，当函数运行时间超过了这个阈值，就算还有很多过期键没有清理，函数也强制退出。

在快速模式下，timelimit的值是固定的，是一个预定义的常量ACTIVE_EXPIRE_CYCLE_FAST_DURATION，在慢速模式下，这个变量的值是通过下面的代码计算的。

timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100;

他的计算依据是之前预定义好的每次迭代只能占用的CPU时间比例，以及这个函数被调用的频率。

Redis中也可能有多个数据库，所以这个函数会遍历多个数据库来清楚过期键 ，但是是根据下面代码的原则来确定要遍历的数据库的个数的。

 if (dbs_per_call > server.dbnum || timelimit_exit)
        dbs_per_call = server.dbnum;

dbs_per_call变量就是函数会遍历的数据库的个数，他有一个预定义的值REDIS_DBCRON_DBS_PER_CALL，但是如果这个值大于现在redis中本身的数据库的个数，我们就要将它的值变成当前的数据库的实际个数，或者上次的函数是因为超时强制退出了，说明可能有的数据库在上次函数调用时没有遍历到，里面的过期键没有清理掉，所以也要将这次遍历的数据库的个数改成实际数据库的个数。

for (j = 0; j < dbs_per_call; j++) {
    int expired;
    redisDb *db = server.db+(current_db % server.dbnum);
      current_db++;

上面代码可以看出：数据库的遍历是在这个大的for循环里，其中值得留意的是current_db这个变量是一个static变量，这么做的好处是，如果真的发生了我们上面说的情况，上一次函数调用因为超时而强制退出，这个变量就会记录下这一次函数应该从哪个数据库开始遍历，这样会使得函数用在每个数据库的时间尽量平均，就不会出现有的数据库里面的过期键一直没有清理的情况。

每个数据库的过期键清理的操作是在下面的这个do while 循环中（由于代码过长，所以中间有很多代码我把它隐藏了，现在看到的只是一个大框架，稍后我会对其中的部分详细讲解）

do {
    ... 
    /* If there is nothing to expire try next DB ASAP. */
    if ((num = dictSize(db->expires)) == 0) {
    ... 
    }
    slots = dictSlots(db->expires);
    now = mstime();

    if (num && slots > DICT_HT_INITIAL_SIZE &&
        (num*100/slots < 1)) break;
        ...
    if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
        num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;

    while (num--) {
     ... 
    }
    /* Update the average TTL stats for this database. */
    if (ttl_samples) {
    ...
    }
    iteration++;
    if ((iteration & 0xf) == 0) { /* check once every 16 iterations. */
    ...
    }
    if (timelimit_exit) return;

} while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);

注意while循环条件，ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP是我们每个循环希望查到的过期键的个数，如果我们每次循环过后，被清理的过期键的个数超过了我们期望的四分之一，我们就会继续这个循环，因为这说明当前数据库中过期键的个数比较多，需要继续清理，如果没有达到我们期望的四分之一，就跳出while循环，遍历下一个数据库。

这个函数最核心的功能就是清除过期键，这个功能的实现就是在while（num–）这个循环里面。

while (num--) {
    dictEntry *de;
    long long ttl;

    if ((de = dictGetRandomKey(db->expires)) == NULL) break;
    ttl = dictGetSignedIntegerVal(de)-now;
    if (activeExpireCycleTryExpire(db,de,now)) expired++;
    if (ttl < 0) ttl = 0;
    ttl_sum += ttl;
    ttl_samples++;
}

他先从数据库中设置了过期时间的键的集合中随机抽取一个键，然后调用activeExpireCycleTryExpire函数来判断这个键是否过期，如果过期就删除键，activeExpireCycleTryExpire函数的源码如下：

int activeExpireCycleTryExpire(redisDb *db, dictEntry *de, long long now) {
    long long t = dictGetSignedIntegerVal(de);
    if (now > t) {
        sds key = dictGetKey(de);
        robj *keyobj = createStringObject(key,sdslen(key));

        propagateExpire(db,keyobj);
        dbDelete(db,keyobj);
        notifyKeyspaceEvent(REDIS_NOTIFY_EXPIRED,
            "expired",keyobj,db->id);
        decrRefCount(keyobj);
        server.stat_expiredkeys++;
        return 1;
    } else {
        return 0;
    }
}

这个函数的逻辑很简单，就是先获取键de的过期时间，和现在的时间比较，如果过期，就生成该键de的对象，然后传播该键de的过期信息，并且删除这个键，然后增加过期键总数。

最后就是控制函数运行时间的部分了，代码如下：

/* 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. */
iteration++;
if ((iteration & 0xf) == 0) { /* check once every 16 iterations. */
    long long elapsed = ustime()-start;

    latencyAddSampleIfNeeded("expire-cycle",elapsed/1000);
    if (elapsed > timelimit) timelimit_exit = 1;
}
if (timelimit_exit) return;     

这里有一个迭代次数的变量iteration，每迭代16次就来计算函数已经运行的时间，如果这个时间超过了之前的限定时间timelimit，就将timelimit_exit这个标志置为1，说明程序超时，需要强制退出了。

（3）懒惰淘汰策略：

1）含义：

key过期的时候不删除，每次通过key获取值的时候去检查是否过期，若过期，则删除，返回null。

2）优点：

删除操作只发生在通过key取值的时候发生，而且只删除当前key，所以对CPU时间的占用是比较少的，而且此时的删除是已经到了非做不可的地步（如果此时还不删除的话，我们就会获取到了已经过期的key了）

3）缺点：

若大量的key在超出超时时间后，很久一段时间内，都没有被获取过，那么可能发生内存泄露（无用的垃圾占用了大量的内存）

4）懒惰式策略删除流程：

1. 在进行get或setnx等操作时，先检查key是否过期；
2. 若过期，删除key，然后执行相应操作； 若没过期，直接执行相应操作；

5）源码阅读：

在redis源码中，实现懒惰淘汰策略的是函数expireIfNeeded，所有读写数据库命令在执行之前都会调用expireIfNeeded函数对输入键进行检查。如果过期就删除，如果没过期就正常访问。

int expireIfNeeded(redisDb *db, robj *key) {
    mstime_t when = getExpire(db,key);
    mstime_t now;

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

    /* Don't expire anything while loading. It will be done later. */
    if (server.loading) return 0;

    /* If we are in the context of a Lua script, we claim that time is
     * blocked to when the Lua script started. This way a key can expire
     * only the first time it is accessed and not in the middle of the
     * script execution, making propagation to slaves / AOF consistent.
     * See issue #1525 on Github for more information. */
    now = server.lua_caller ? server.lua_time_start : mstime();

    /* If we are running in the context of a slave, return ASAP:
     * the slave key expiration is controlled by the master that will
     * send us synthesized DEL operations for expired keys.
     *
     * Still we try to return the right information to the caller,
     * that is, 0 if we think the key should be still valid, 1 if
     * we think the key is expired at this time. */
    /*如果我们正在slaves上执行读写命令，就直接返回，
     *因为slaves上的过期是由master来发送删除命令同步给slaves删除的，
     *slaves不会自主删除*/
    if (server.masterhost != NULL) return now > when;
    /*只是回了一个判断键是否过期的值，0表示没有过期，1表示过期
     *但是并没有做其他与键值过期相关的操作*/

    /* Return when this key has not expired */
    /*如果没有过期，就返回当前键*/
    if (now <= when) return 0;

    /* Delete the key */
    /*增加过期键个数*/
    server.stat_expiredkeys++;
    /*传播键过期的消息*/
    propagateExpire(db,key);
    notifyKeyspaceEvent(REDIS_NOTIFY_EXPIRED,"expired",key,db->id);
    /*删除过期键*/
    return dbDelete(db,key);
}

以上是expireIfNeeded函数的源码，源码中的注释已经很清楚的描述出了它的逻辑，我只是将他翻译成中文，然后加了一点自己的注释。值得注意的如果是slaves,它是不能自主删除键的，需要由master发del命令，然后同步到所有的slaves，这样就不会造成主从数据不一致的问题。

（4）策略总述：

懒惰淘汰机制和定时淘汰机制是一起合作的，就好像你开一家餐馆一样，定时淘汰机制就是你每隔几小时去查看所有的菜品是否还有，如果有的菜品现在卖光了，就将他从菜单上划掉。懒惰淘汰机制就是有客人要点宫保鸡丁，你马上去查看还有没有，如果今天的已经卖完了，就告诉客人不好意思，我们卖完了，然后将宫保鸡丁从菜单上划掉。只有等下次有原料再做的时候，才又把它放到菜单上去。

所以，在实际中，如果我们要自己设计过期策略，在使用懒汉式删除+定期删除时，控制时长和频率这个尤为关键，需要结合服务器性能，已经并发量等情况进行调整，以致最佳。

---

三、对开发需求而言，Redis过期策略的设计实现经验：代码在此工程里

（1）分析缓存键值的客户方角度，调和服务器内存压力

基于服务器内存是有限的，但是缓存是必须的，所以我们就要结合起来选择一个平衡点。所以一般来说，我们采取高访问量缓存策略—就是给那些经常被访问的数据，维持它较长的key生存周期。

（2）估算过期时间

这个就要结合我们自己的业务去估量了。

参考因素：数据的访问量、并发量，数据的变化更新的时间，服务器数据内存大小…

（3）Java演示一策略做法。

每次访问刷新对应key生存时间：

针对经常访问的数据的策略

//加进redis时，设置生存时间
@Override
    public String set(String key, String value) {
        Jedis jedis = jedisPool.getResource();
        String string = jedis.set(key, value);
        jedis.expire(key,5);
        System.out.println("key :  "+key);
        System.out.println("查看key的剩余生存时间："+jedis.ttl(key));
        jedis.close();
        return string;
    }
    //从redis获取时
 @Override
    public String get(String key) {
        Jedis jedis = jedisPool.getResource();
        String string = jedis.get(key);
        jedis.expire(key,5);//每次访问刷新时间
        jedis.close();
        return string;
    }

源码下载：Redis系列（三）–过期策略的数据库以及部分实现代码

好了，Redis系列（三）–过期策略讲完了，这是redis使用优化必须理解的原理，这是积累的必经一步

我会继续出这个系列文章，分享经验给大家。欢迎在下面指出错误，共同学习！！你的点赞是对我最好的支持！！

更多内容，可以访问JackFrost的博客