MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Redis设置键存活时长的实用策略

2021-04-211.2k 阅读

Redis键存活时长概述

在Redis中，为键设置存活时长是一项强大且常用的功能。通过设置键的存活时长，我们可以有效地管理内存使用，确保数据的时效性，并且实现诸如缓存过期、限时任务等功能。

Redis提供了多种方式来设置键的存活时长，这一特性依赖于Redis的内部机制，即当一个键设置了过期时间后，Redis会在内部维护一个过期字典，该字典记录了所有设置了过期时间的键及其过期时间戳。每当执行读写操作时，Redis会检查键是否过期，如果过期则会将其删除。

设置键存活时长的基本方法

EXPIRE命令

EXPIRE命令用于设置一个键的过期时间，以秒为单位。语法如下：

EXPIRE key seconds

例如，我们要为键mykey设置60秒的过期时间，可以这样操作：

127.0.0.1:6379> SET mykey "Hello, Redis!"
OK
127.0.0.1:6379> EXPIRE mykey 60
(integer) 1

上述代码中，首先使用SET命令设置了键mykey的值，然后使用EXPIRE命令为其设置了60秒的过期时间。返回值(integer) 1表示设置成功，若返回(integer) 0则表示键不存在或设置失败。

PEXPIRE命令

PEXPIRE命令与EXPIRE类似，不过它是以毫秒为单位设置键的过期时间。语法为：

PEXPIRE key milliseconds

示例：

127.0.0.1:6379> SET anotherkey "Some data"
OK
127.0.0.1:6379> PEXPIRE anotherkey 5000
(integer) 1

这里为anotherkey设置了5000毫秒（即5秒）的过期时间。

SETEX命令

SETEX命令在设置键值对的同时可以设置过期时间，同样以秒为单位。语法为：

SETEX key seconds value

例如：

127.0.0.1:6379> SETEX newkey 30 "This key will expire in 30 seconds"
OK

上述代码在设置newkey的值的同时，设置了其30秒后过期。

PSETEX命令

PSETEX命令则是在设置键值对时以毫秒为单位设置过期时间。语法为：

PSETEX key milliseconds value

示例：

127.0.0.1:6379> PSETEX newkey2 2000 "Expires in 2 seconds"
OK

此代码为newkey2设置了2000毫秒（2秒）的过期时间并设置了值。

获取键的剩余存活时间

TTL命令

TTL命令用于获取一个键的剩余存活时间，以秒为单位。语法为：

TTL key

示例：

127.0.0.1:6379> SET mykey "Some value"
OK
127.0.0.1:6379> EXPIRE mykey 120
(integer) 1
127.0.0.1:6379> TTL mykey
(integer) 115

这里先设置了mykey的值并为其设置了120秒的过期时间，然后使用TTL命令获取其剩余存活时间，返回值115表示大约还剩115秒过期。如果键不存在或者没有设置过期时间，TTL命令会返回-1和-2。返回-1表示键存在但没有设置过期时间，返回-2表示键不存在。

PTTL命令

PTTL命令与TTL类似，不过它返回的剩余存活时间是以毫秒为单位。语法为：

PTTL key

示例：

127.0.0.1:6379> SET anotherkey "Some data"
OK
127.0.0.1:6379> PEXPIRE anotherkey 10000
(integer) 1
127.0.0.1:6379> PTTL anotherkey
(integer) 9567

这里为anotherkey设置了10000毫秒的过期时间，然后使用PTTL命令获取其剩余存活时间为9567毫秒。

移除键的过期时间

PERSIST命令

PERSIST命令用于移除一个键的过期时间，使其成为一个持久化的键。语法为：

PERSIST key

示例：

127.0.0.1:6379> SET mykey "Some value"
OK
127.0.0.1:6379> EXPIRE mykey 60
(integer) 1
127.0.0.1:6379> PERSIST mykey
(integer) 1
127.0.0.1:6379> TTL mykey
(integer) -1

首先设置mykey的值并为其设置60秒过期时间，然后使用PERSIST命令移除过期时间，最后使用TTL命令验证，返回-1表示键存在但没有过期时间，说明移除成功。如果键不存在或者已经是持久化的（没有过期时间），PERSIST命令会返回0。

基于业务场景的键存活时长设置策略

缓存场景

在缓存场景中，合理设置键的存活时长至关重要。如果存活时长设置过长，可能导致缓存数据长时间不更新，应用程序使用到的是旧数据；如果设置过短，则可能频繁地从数据源（如数据库）重新获取数据，增加系统负载。

对于一些不经常变化的数据，如网站的配置信息、商品分类等，可以设置较长的存活时长，例如数小时甚至数天。例如：

127.0.0.1:6379> SET config:site_settings "..."
OK
127.0.0.1:6379> EXPIRE config:site_settings 86400 # 设置一天的过期时间
(integer) 1

而对于一些变化相对频繁的数据，如用户的实时信息、商品的库存等，存活时长应该设置得较短，比如几分钟甚至几十秒。示例：

127.0.0.1:6379> SET user:1:info "..."
OK
127.0.0.1:6379> EXPIRE user:1:info 300 # 设置5分钟的过期时间
(integer) 1

在实际应用中，还可以结合一些动态调整策略。比如，当从数据源获取数据时，可以根据数据的更新频率来动态调整缓存键的存活时长。如果发现数据更新频繁，则缩短存活时长；如果数据长时间未更新，则适当延长存活时长。

限时任务场景

在实现限时任务时，我们可以利用Redis键的过期机制。例如，我们要实现一个在10分钟后执行某个任务的功能，可以这样做：

127.0.0.1:6379> SET task:1 "..."
OK
127.0.0.1:6379> EXPIRE task:1 600 # 设置10分钟的过期时间
(integer) 1

然后通过订阅Redis的过期事件（可以使用pubsub机制），当task:1过期时，收到过期事件通知，从而触发相应的任务执行逻辑。在Python中，可以使用redis - py库来实现这一功能：

import redis

r = redis.Redis(host='localhost', port=6379, db = 0)

def subscribe_expired_events():
    pubsub = r.pubsub()
    pubsub.psubscribe('__keyevent@0__:expired')
    for message in pubsub.listen():
        if message['type'] == 'pmessage':
            expired_key = message['data'].decode('utf - 8')
            if expired_key.startswith('task:'):
                print(f"Task {expired_key} has expired, execute the task...")

if __name__ == "__main__":
    subscribe_expired_events()

上述代码通过订阅__keyevent@0__:expired频道，监听所有过期事件，当发现以task:开头的键过期时，打印相应的提示信息，实际应用中这里可以替换为具体的任务执行逻辑。

防止缓存雪崩场景

缓存雪崩是指在大量缓存键同时过期的情况下，大量请求直接穿透到后端数据源，导致数据源负载过高甚至崩溃。为了防止缓存雪崩，可以采用以下策略来设置键的存活时长。

一种策略是为缓存键设置随机的过期时间。例如，原本要设置缓存键存活时间为1小时，可以在50分钟到70分钟之间随机选择一个时间作为过期时间。在Java中使用Jedis库实现如下：

import redis.clients.jedis.Jedis;
import java.util.Random;

public class RedisCache {
    private Jedis jedis;

    public RedisCache() {
        jedis = new Jedis("localhost", 6379);
    }

    public void setWithRandomExpiry(String key, String value) {
        Random random = new Random();
        int expiry = 50 * 60 + random.nextInt(20 * 60); // 50到70分钟之间的随机秒数
        jedis.setex(key, expiry, value);
    }

    public static void main(String[] args) {
        RedisCache cache = new RedisCache();
        cache.setWithRandomExpiry("myKey", "myValue");
    }
}

另一种策略是使用“热数据”和“冷数据”区分。对于经常被访问的热数据，设置较长的过期时间，并采用主动更新机制，定期从数据源更新数据到缓存中，而不是依赖过期时间。对于冷数据，则可以设置相对较短的过期时间，以节省内存空间。

分布式环境下键存活时长的考虑

在分布式环境中，使用Redis设置键存活时长需要额外注意一些问题。由于多个节点可能同时操作Redis，可能会出现竞争条件。例如，多个节点同时尝试设置同一个键的过期时间，可能导致过期时间被意外覆盖。

为了解决这个问题，可以使用分布式锁。以Redisson库为例，在Java中实现如下：

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

public class DistributedRedisExpiry {
    private RedissonClient redissonClient;

    public DistributedRedisExpiry() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://localhost:6379");
        redissonClient = Redisson.create(config);
    }

    public void setKeyWithExpiry(String key, String value, int seconds) {
        RLock lock = redissonClient.getLock(key + ":lock");
        try {
            lock.lock();
            redissonClient.getBucket(key).set(value);
            redissonClient.getBucket(key).expire(seconds);
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        DistributedRedisExpiry redisExpiry = new DistributedRedisExpiry();
        redisExpiry.setKeyWithExpiry("sharedKey", "sharedValue", 60);
    }
}

上述代码通过Redisson获取分布式锁，在设置键值对及过期时间时持有锁，确保操作的原子性，避免了竞争条件。

另外，在分布式环境中，还需要考虑不同节点之间的时钟同步问题。如果节点之间时钟差异较大，可能会导致键的过期时间计算不准确。可以通过使用网络时间协议（NTP）来同步各个节点的时钟，确保时间的一致性。

Redis集群环境下键存活时长的特性

在Redis集群环境中，键的过期时间管理与单机环境有一些不同。Redis集群采用哈希槽（Hash Slot）的方式来分配键值对，每个节点负责一部分哈希槽。

当设置一个键的过期时间时，该过期信息会在集群中传播。所有节点都会维护过期字典，并且在执行读写操作时都会检查键是否过期。但是，由于集群节点之间的复制和同步机制，可能会存在一定的延迟。

例如，当一个主节点上的键过期时，它会向从节点发送过期消息。然而，如果网络延迟或者其他原因导致从节点没有及时收到过期消息，从节点可能在主节点删除键之后仍然会返回该键的值。为了尽量减少这种情况的影响，可以通过调整集群的复制策略和心跳频率等参数来优化。

在Redis集群中，也可以使用CLUSTER GETKEYSINSLOT命令获取某个哈希槽中的所有键，结合TTL或PTTL命令，可以批量检查这些键的剩余存活时间，从而进行统一的管理和维护。示例：

127.0.0.1:6379> CLUSTER GETKEYSINSLOT 0 10 # 获取哈希槽0中的10个键
1) "key1"
2) "key2"
...
127.0.0.1:6379> TTL key1
(integer) 120
127.0.0.1:6379> TTL key2
(integer) -1

上述代码先获取了哈希槽0中的10个键，然后分别检查了key1和key2的剩余存活时间。

内存管理与键存活时长的关系

合理设置键的存活时长对于Redis的内存管理至关重要。当一个键过期时，Redis会自动释放该键所占用的内存空间。但是，如果大量键在短时间内同时过期，可能会导致内存使用量的突然波动，影响系统的稳定性。

为了更好地管理内存，我们可以结合Redis的内存淘汰策略。Redis提供了多种内存淘汰策略，如noeviction（不淘汰任何键，当内存不足时，写入操作会报错）、volatile - lru（在设置了过期时间的键中，使用最近最少使用算法淘汰键）、allkeys - lru（在所有键中使用最近最少使用算法淘汰键）等。

如果我们设置了较多的短期存活键，可以考虑使用volatile - lru策略，这样在内存不足时，优先淘汰那些设置了过期时间且最近最少使用的键，避免影响到长期存活的重要键。而如果系统中有很多键都没有设置过期时间，但内存有限，可以使用allkeys - lru策略。

例如，通过修改Redis配置文件redis.conf来设置内存淘汰策略为volatile - lru：

maxmemory - policy volatile - lru

然后重启Redis服务使配置生效。这样，在内存不足时，Redis会根据volatile - lru策略淘汰设置了过期时间的键，以保证系统的正常运行。

同时，我们还可以通过监控Redis的内存使用情况，如使用INFO memory命令获取内存相关信息，根据实际情况动态调整键的存活时长和内存淘汰策略。

127.0.0.1:6379> INFO memory
# Memory
used_memory:1073741824
used_memory_human:1.00G
used_memory_rss:1234567890
used_memory_rss_human:1.15G
...

上述命令返回了Redis当前使用的内存量（used_memory）、RSS内存量（used_memory_rss）等信息，我们可以根据这些信息来判断是否需要调整键的存活时长或内存淘汰策略。

总结键存活时长设置的要点与优化方向

在设置Redis键存活时长时，需要深入理解业务需求。不同的业务场景对键的存活时长有不同的要求，要根据数据的更新频率、重要性以及系统的负载情况来合理设置。

从技术实现角度，要熟悉各种设置和获取存活时长的命令，并且注意在分布式和集群环境中的特殊情况。通过使用分布式锁解决竞争条件，通过时钟同步确保时间一致性，以及了解集群环境下过期信息的传播和处理机制。

在内存管理方面，结合内存淘汰策略，根据键的存活特点和内存使用情况进行优化。同时，持续监控内存使用和键的过期情况，以便及时调整策略。通过综合考虑这些方面，我们能够制定出高效、稳定且符合业务需求的Redis键存活时长设置策略，充分发挥Redis在数据缓存、限时任务等场景中的优势。

在实际应用中，还可以不断探索新的优化方法。例如，结合机器学习算法，根据历史数据和实时数据预测数据的使用频率和更新频率，从而更加智能地设置键的存活时长。另外，随着硬件技术的发展，如更快的网络、更大的内存等，也可以进一步优化键存活时长的设置策略，以适应新的环境和业务需求。

通过对Redis键存活时长设置策略的深入研究和实践，我们能够更好地利用Redis的功能，提高系统的性能和稳定性，为应用程序提供更可靠的数据支持。无论是小型应用还是大型分布式系统，合理设置键的存活时长都是优化Redis使用的重要一环。在未来的技术发展中，随着Redis功能的不断增强和应用场景的不断拓展，键存活时长设置策略也将不断演进和完善，需要我们持续关注和学习。