制定Redis过期策略，是整个Redis缓存策略的关键之一，因为内存来说，公司不可能无限大，所以就要对key进行一系列的管控。
文章结构：（1）理解Redis过期设置API（命令与Java描述版本）；（2）理解Redis内部的过期策略；（3）对开发需求而言，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 <key> < timestamp> 命令用于将键key 的过期时间设置为timestamp所指定的秒数时间戳。
PEXPIREAT <key> < 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使用优化必须理解的原理，这是积累的必经一步，我会继续出这个系列文章，分享经验给大家。欢迎在下面指出错误，共同学习！！你的点赞是对我最好的支持！！
