贾明最近在家做了一次大扫除，收拾出来很多没用的东西，变卖的变卖，送人的送人，扔掉的扔掉。家里宽敞很多。

为什么要给key设置过期时间

内存是非常昂贵的，在Redis中设置key的时候，同时设置key的过期时间，可以确保Redis中的数据不会无限增长，在key过期后由Redis自行删除。节约内存空间。

而且在一些应用场景中，仅仅需要在Redis短时间保存值，如果不设置key的过期时间，则需要我们在程序中自行删除，加重了程序员的心智负担。

如何设置key过期时间

一般情况下，通过使用 Redis 的 EXPIRE 或 PEXPIRE 命令，客户端可以以秒或毫秒的精度设置键（key）的生存时间（Time To Live：TTL）。

其中EXPIRE 命令以秒为单位设置键的生存时间，而 PEXPIRE 命令以毫秒为单位设置键的生存时间。

127.0.0.1:6379> SET key value
OK
127.0.0.1:6379> GET key
"value"
127.0.0.1:6379> EXPIRE key 5
(integer) 1
127.0.0.1:6379> GET key
"value"
127.0.0.1:6379> GET key
(nil)

也可以通过EXPIREAT命令或PEXPIREAT命令设置key的过期时间（expire time）。

其中EXPIREAT命令以秒为单位设置key 的过期时间，PEXPIREAT命令以毫秒设置key的过期时间。

127.0.0.1:6379> SET key value
OK
127.0.0.1:6379> GET key
"value"
127.0.0.1:6379> EXPIREAT key 1700137857
(integer) 1
127.0.0.1:6379> GET key
"value"
127.0.0.1:6379> GET key
(nil)

SETEX命令可以在设置一个字符串键的同时为键设置过期时间，因为这个命令是一个类型限定的命令（只能用于字符串键）

设置key的过期时间有四种方式：

1. EXPIRE：设置key的生存时间为ttl秒；EXPIRE < key > < ttl >
2. PEXPIRE：设置key的生存时间为ttl毫秒；PEXPIRE < key > < ttl >
3. EXPIREAT：设置key的生存时间为timestamp指定的秒数时间戳；EXPIREAT < key > < timestamp >
4. PEXPIREAT：设置key的生存时间为timestamp指定的毫秒数时间戳；PEXPIREAT < key > < timestamp >

虽然有多种命令设置key的过期时间，实际上，上面四个命令都是调用expireGenericCommand函数实现的。代码位于expire.c

/* EXPIRE key seconds [ NX | XX | GT | LT] */
void expireCommand(client *c) {
    expireGenericCommand(c,mstime(),UNIT_SECONDS);
}

/* EXPIREAT key unix-time-seconds [ NX | XX | GT | LT] */
void expireatCommand(client *c) {
    expireGenericCommand(c,0,UNIT_SECONDS);
}

/* PEXPIRE key milliseconds [ NX | XX | GT | LT] */
void pexpireCommand(client *c) {
    expireGenericCommand(c,mstime(),UNIT_MILLISECONDS);
}

/* PEXPIREAT key unix-time-milliseconds [ NX | XX | GT | LT] */
void pexpireatCommand(client *c) {
    expireGenericCommand(c,0,UNIT_MILLISECONDS);
}

void expireGenericCommand(client *c, long long basetime, int unit) {
    robj *key = c->argv[1], *param = c->argv[2];
    longlong when; /* unix time in milliseconds when the key will expire. */
    longlong current_expire = -1;
    int flag = 0;

    ...

    /* EXPIRE allows negative numbers, but we can at least detect an
     * overflow by either unit conversion or basetime addition. */
    if (unit == UNIT_SECONDS) {
        if (when > LLONG_MAX / 1000 || when < LLONG_MIN / 1000) {
            addReplyErrorExpireTime(c);
            return;
        }
        when *= 1000;
    }

    if (when > LLONG_MAX - basetime) {
        addReplyErrorExpireTime(c);
        return;
    }
    when += basetime;
    ...
}

过期时间是怎么保存的

redisDb结构的expires字典保存了数据库中所有键的过期时间，我们称这个字典为过期字典。

过期字典的结构：

1. 过期字典的key是一个指针，指向具体的某个key。
2. 过期字典的值是个long类型的整数，保存了key对应的过期时间（毫秒级的UNIX时间戳）。

typedefstruct redisDb {
    ...
    dict *expires;              /* Timeout of keys with a timeout set */
    ...
} redisDb;

过期字典案例

上图为带有过期字典的结构，key空间保存了所有的key-value ，过期字典保存了过期时间。

为了展示方便，上图的key空间和过期字典中重复出现了两次alphabet键对象和book键对象。在实际中，key空间的key和过期字典的key都是指针，指向了同一个key对象，所以不会出现任何重复对象，也不会浪费任何空间。

移除过期时间

PERSIST可以用来移除一个key的过期时间。PERSIST < key >

127.0.0.1:6379> set key value
OK
127.0.0.1:6379> expire key 100
(integer) 1
127.0.0.1:6379> ttl key
(integer) 96
127.0.0.1:6379> PERSIST key
(integer) 1
127.0.0.1:6379> ttl key
(integer) -1

计算过期时间

TTL

获取以秒为单位返回键的剩余生存时间

TTL < key >

PTTL

获取以毫秒为单位返回键的剩余生存时间

PTTL < key >

过期判定

1. 先判断是否在过期字典中
2. 再根据当前的UNIX时间戳是否大于key的过期时间戳

过期策略

到了这里，我们已经知道了key的过期时间都是存在过期字典中的。也知道了该如何去判断key是否已经过期。那么问题来了，如果一个key过期了，什么时候去删除呢？

可能有三种实现方式：

1. 定时删除：设置一个key过期时间后，同时创建一个timer定时器。在key过期的时候，由timer处理key的删除。
2. 惰性删除：一个key过期后，不进行处理，下次获取的时候，先判断key是否过期，如果过期，则删除。
3. 定期删除：每隔一段时间，对key进行扫描一遍，如果过期则删除，至于扫描key的个数和时间间隔可以根据算法决定。

定时删除策略

优点：内存友好，能够及时清理过期key。

缺点：CPU时间不友好，在过期key较多的情况下，删除过期key可能会占用相当一部分CPU时间。尤其在内存不紧张但CPU时间非常紧张的情况下，将CPU时间用于删除与当前任务无关的过期key，无疑会对服务器的响应时间和吞吐量造成影响。

例如，如果正有大量的命令请求在等待服务器处理，并且服务器当前不缺少内存，那么服务器应该优先将CPU时间用在处理客户端的命令请求上面，而不是用在删除过期key上面。

惰性删除策略

优点是对CPU友好，只有在查询的时候，才去判断key是否过期，如果过期就进行删除操作。并且只会操作当前key，对其他key不会进行操作。该策略不会在其他过期key上耗费时间。

但是对内存不好，如果一个key过期了，而又没有进行访问，这个key会一直留在内存中。占用的内容不会得到释放。

试想一下，如果有大量的key过期了，但又没有进行访问，它们一直得不到删除，会一直驻留在内存中，无疑是一笔巨大的负担。

定期删除策略

定期删除可以说是定时删除和惰性删除的中和，每隔一段时间，扫描一下，进行过期key删除操作。可以通过限制执行频率和执行时间来，来避免占用过多的CPU。

实际上，Redis采用的是惰性删除和定期删除两种策略。通过配合使用这两种删除策略，服务器可以很好地在合理使用CPU时间和避免浪费内存空间之间取得平衡

删除策略的实现

本节我们来看下Redis中两种删除策略的代码实现。

惰性删除实现

• 当客户端执行读写操作时，Redis 在检索key之前会检查其过期时间。如果key已过期，则 Redis 返回一个表示key不存在的响应，并在需要时进行惰性删除。
• 惰性删除是指在读取或写入key之前，Redis 会检查该键是否过期。如果过期，则立即删除该key。

定期删除实现

• Redis 使用一个定时器来周期性地执行定期删除操作，以清理过期key。
• 定期删除是通过遍历数据库中的过期key来进行的。
• 在每个定期删除周期内，Redis 随机选择一部分过期键进行处理。
• 对于被选中的过期key，Redis 遍历它们，并检查每个key的过期时间。如果某个key已经过期，则将其删除并释放相关的内存空间
• 在处理过期键时，Redis 记录已删除的键数量，并在超过阈值后停止遍历，以避免长时间的阻塞操作。

AOF、RDB、复制的影响

AOF

AOF写入

Redis开启AOF后，如果某个key过期，如果这个时候还没执行惰性删除或者定期删除，那么AOF文件不会产生变化。当惰性删除或者定期删除执行过之后，会向AOF文件中显示写入一条DEL命令。

比如访问过期的key1会经历下面的流程（惰性删除为例）：

1. 删除key1
2. 向AOF文件追加DEL key1命令
3. 向客户端返回空

AOF重写

AOF重写的时候，会对key进行检查，如果发现key已经过期，不会重写到AOF文件中。和下文的RDB加载很类似。

RDB

生成RDB

在调用BGSAVE命令或者SAVE命令新生成RDB文件的时候，Redis会检查key是否过期，如果key已经过期，则不会写入RDB文件中。

比如假设Redis中有三个key，key1，key2，key3。其中key2已经过期，那么写入RDB的时候，会把key2忽略，将key1和key3写入RDB文件中。

加载RDB

Redis启动的时候，如果开了RDB模式，将会在启动过程中加载RDB文件。

1. 如果是在主节点上运行，Redis会对key进行检查，未过期的key加载到Redis中，过期key则忽略。
2. 如果是在从节点上运行，Redis不会对key进行检查，无论key是否过期，都会加载到Redis中。

复制

在复制模式下，过期key的删除由主节点进行操作，从节点不进行处理。

1. 主节点在删除一条key后，会向所有的从节点发送一条DEL命令。
2. 从节点在执行读命令的时候，遇见过期key不会进行删除操作。
3. 从节点接收到主节点发来的DEL命令，执行删除key操作。

这么做是为了保证主从一致性。删除的操作统一由主节点执行，避免了从节点上已经删除但是主节点还存在的情况。