Redis字符串命令SET与GET的深入解析
Redis 字符串命令 SET 与 GET 基础介绍
Redis 是一个开源的基于键值对的内存数据存储系统，常用于缓存、消息队列、分布式锁等场景。在 Redis 中，字符串是最基本的数据类型之一，而 SET 和 GET 命令是操作字符串类型数据的核心命令。
SET 命令概述
SET 命令用于将一个指定的字符串值关联到一个键上。如果键已经存在，那么它的旧值会被覆盖。SET 命令的基本语法如下：
SET key value [EX seconds] [PX milliseconds] [NX|XX]
- key：要设置值的键名，键名必须是唯一的，否则旧值会被覆盖。
- value：要设置到键上的字符串值。这个值可以是任意的字符串，包括空字符串。
- EX seconds：可选参数，设置键的过期时间，单位为秒。例如
SET mykey "hello" EX 60，表示设置键mykey的值为hello，并且 60 秒后该键会自动过期被删除。 - PX milliseconds：可选参数，设置键的过期时间，单位为毫秒。比如
SET mykey "world" PX 10000，即设置mykey的值为world，10000 毫秒（10 秒）后过期。 - NX：可选参数，只在键不存在时，才对键进行设置操作。例如
SET mykey "newvalue" NX，如果mykey不存在，就设置值为newvalue；如果mykey已经存在，则不进行任何操作。 - XX：可选参数，只在键已经存在时，才对键进行设置操作。例如
SET mykey "updatevalue" XX，若mykey存在，就更新其值为updatevalue；若mykey不存在，则不执行操作。
GET 命令概述
GET 命令用于获取指定键的值。如果键不存在，返回 nil。其基本语法非常简单：
GET key
例如，我们先使用 SET 命令设置一个键值对：
SET mykey "Hello, Redis!"
然后使用 GET 命令获取这个键的值：
GET mykey
Redis 会返回 "Hello, Redis!"。
SET 命令深入解析
SET 命令的原子性
在 Redis 中，SET 命令是原子性的。这意味着，在多个客户端同时对同一个键执行 SET 操作时，不会出现部分更新的情况。每个 SET 操作要么完整执行，要么根本不执行。例如，假设有两个客户端 A 和 B 同时尝试对键 counter 进行 SET 操作：
- 客户端 A 执行
SET counter 1。 - 客户端 B 执行
SET counter 2。
无论这两个操作多么接近，最终 counter 的值要么是 1，要么是 2，不会出现一个中间状态，比如 12 或者 21。这种原子性保证了在多客户端并发操作下数据的一致性。
SET 命令的应用场景 - 缓存数据
SET 命令最常见的应用场景之一就是缓存数据。假设我们有一个网站，需要频繁从数据库中查询某个用户的信息。为了减轻数据库的压力，我们可以将查询结果缓存到 Redis 中。例如，我们从数据库中获取用户 user1 的信息：
import redis
import pymysql
# 连接 Redis
r = redis.Redis(host='localhost', port=6379, db=0)
# 连接 MySQL 数据库
conn = pymysql.connect(host='localhost', user='root', password='password', database='test')
cursor = conn.cursor()
# 从数据库查询用户信息
sql = "SELECT * FROM users WHERE username = 'user1'"
cursor.execute(sql)
user_info = cursor.fetchone()
# 将用户信息缓存到 Redis
r.set('user:user1', str(user_info))
之后，当再次需要获取 user1 的信息时，我们可以先尝试从 Redis 中获取：
user_info_from_redis = r.get('user:user1')
if user_info_from_redis:
print("从 Redis 缓存中获取到用户信息:", user_info_from_redis)
else:
# 如果 Redis 中没有，再从数据库查询并缓存
sql = "SELECT * FROM users WHERE username = 'user1'"
cursor.execute(sql)
user_info = cursor.fetchone()
r.set('user:user1', str(user_info))
print("从数据库获取并缓存到 Redis，用户信息:", user_info)
通过这种方式，大部分情况下可以直接从 Redis 中快速获取数据，减少对数据库的查询次数，提高系统的响应速度。
SET 命令的应用场景 - 分布式锁
在分布式系统中，常常需要使用分布式锁来保证在多个节点间对共享资源的互斥访问。SET 命令结合 NX 参数可以实现一个简单的分布式锁。例如，假设有多个节点都需要访问某个共享资源，如文件系统中的一个文件。我们可以使用以下代码实现分布式锁：
import redis
import time
r = redis.Redis(host='localhost', port=6379, db=0)
def acquire_lock(lock_key, lock_value, expire_time=10):
result = r.set(lock_key, lock_value, ex=expire_time, nx=True)
return result
def release_lock(lock_key, lock_value):
pipe = r.pipeline()
while True:
try:
pipe.watch(lock_key)
if pipe.get(lock_key) == lock_value.encode('utf-8'):
pipe.multi()
pipe.delete(lock_key)
pipe.execute()
return True
pipe.unwatch()
break
except redis.WatchError:
continue
return False
# 尝试获取锁
lock_key = "file_access_lock"
lock_value = str(time.time())
if acquire_lock(lock_key, lock_value):
try:
# 获得锁后执行对共享资源的操作
print("获得锁，开始访问共享资源")
time.sleep(5)
finally:
# 操作完成后释放锁
release_lock(lock_key, lock_value)
print("释放锁")
else:
print("未能获得锁，无法访问共享资源")
在这段代码中，acquire_lock 函数使用 SET 命令的 NX 参数尝试获取锁。如果键不存在，即锁未被占用，SET 操作成功，返回 True，表示获得了锁；否则返回 False。release_lock 函数则负责释放锁，通过 watch 机制保证只有当前持有锁的节点才能释放锁，避免误释放其他节点持有的锁。
GET 命令深入解析
GET 命令的性能优化
在 Redis 中，GET 命令的性能非常高，因为 Redis 是基于内存的存储系统。然而，在实际应用中，还是有一些方法可以进一步优化 GET 命令的性能。
批量获取：如果需要获取多个键的值，使用 MGET 命令比多次使用 GET 命令效率更高。MGET 命令可以一次性获取多个键的值，减少客户端与 Redis 服务器之间的网络通信开销。例如，假设有键 key1、key2 和 key3，我们可以这样获取它们的值：
MGET key1 key2 key3
在 Python 中使用 mget 方法：
import redis
r = redis.Redis(host='localhost', port=6379, db=0)
values = r.mget(['key1', 'key2', 'key3'])
print(values)
合理设置键名：键名的长度和结构也会影响 GET 命令的性能。尽量避免使用过长的键名，因为 Redis 需要为每个键分配内存空间来存储键名和键值对的元数据。同时，合理的键名命名规则有助于快速定位所需的键。例如，对于用户相关的数据，可以使用 user:{username}:{attribute} 的格式，如 user:user1:name、user:user1:age，这样在获取用户特定属性时可以通过键名快速定位。
GET 命令在缓存穿透场景中的应对
缓存穿透是指查询一个一定不存在的数据，由于缓存不命中，每次都会去查询数据库，导致数据库压力增大。在这种情况下，GET 命令会返回 nil，这时候可以采用一些策略来应对。
布隆过滤器：布隆过滤器可以用来判断一个元素是否在一个集合中。我们可以在写入数据到 Redis 缓存时，同时将键添加到布隆过滤器中。当使用 GET 命令获取数据时，先通过布隆过滤器判断键是否可能存在。如果布隆过滤器判断键不存在，那么就直接返回，不再查询数据库，从而避免无效的数据库查询。
以下是使用 pybloomfiltermmap 库在 Python 中实现布隆过滤器与 Redis 结合的示例：
import redis
from pybloomfiltermmap import BloomFilter
# 连接 Redis
r = redis.Redis(host='localhost', port=6379, db=0)
# 创建布隆过滤器，预计元素数量为 10000，误判率为 0.01
bloom = BloomFilter(capacity=10000, error_rate=0.01)
def get_data(key):
if key not in bloom:
return None
value = r.get(key)
if value:
return value.decode('utf-8')
return None
def set_data(key, value):
r.set(key, value)
bloom.add(key)
空值缓存：对于查询不存在的数据，我们可以在 Redis 中缓存一个空值，并设置一个较短的过期时间。例如：
import redis
r = redis.Redis(host='localhost', port=6379, db=0)
def get_data(key):
value = r.get(key)
if value:
if value.decode('utf-8') == 'null':
return None
return value.decode('utf-8')
# 从数据库查询数据
data_from_db = get_data_from_db(key)
if data_from_db:
r.set(key, data_from_db)
return data_from_db
else:
# 缓存空值
r.setex(key, 60, 'null')
return None
def get_data_from_db(key):
# 模拟从数据库查询数据
if key == 'existing_key':
return 'data from db'
return None
在这个示例中，当查询不存在的数据时，先缓存一个空值 null，有效期为 60 秒。在这 60 秒内再次查询相同键时，直接返回 None，避免了重复查询数据库。
SET 和 GET 命令的底层实现
Redis 字符串的内部编码
Redis 字符串对象有三种内部编码方式：int、embstr 和 raw。
int 编码：当字符串的值是一个整数，并且这个整数可以用 long 类型（在 64 位系统上是 64 位有符号整数）表示时，Redis 会使用 int 编码来存储这个字符串对象。例如，SET num 123，如果此时 num 键对应的字符串对象满足 int 编码条件，Redis 会以 int 编码方式存储，这样可以节省内存空间。
embstr 编码：当字符串的长度小于等于 44 字节（这个长度在不同 Redis 版本可能略有不同）时，Redis 会使用 embstr 编码。embstr 编码将 Redis 对象头和字符串内容连续存储在一块内存中，这样可以减少内存碎片，提高内存利用率。例如，SET short_str "hello, world"，如果 short_str 对应的字符串长度满足条件，就会使用 embstr 编码。
raw 编码：当字符串长度大于 44 字节时，Redis 会使用 raw 编码。raw 编码下，Redis 对象头和字符串内容是分开存储的。例如，SET long_str "a very long string that exceeds 44 bytes"，此时 long_str 对应的字符串对象会采用 raw 编码。
SET 命令的底层实现流程
当执行 SET 命令时，Redis 首先会检查键是否存在。如果键存在，Redis 会根据当前键对应的值的内部编码以及新值的情况来决定如何处理。
如果新值可以使用 int 编码，并且当前值也是 int 编码或者可以转换为 int 编码，Redis 会直接更新值。如果新值长度适合 embstr 编码，而当前值是 raw 编码，Redis 可能会将 raw 编码转换为 embstr 编码（如果满足转换条件）。如果新值长度超过 embstr 编码的限制，并且当前值是 embstr 编码，Redis 会将 embstr 编码转换为 raw 编码。
在处理过期时间等参数时，Redis 会将相关信息记录在键的元数据中。例如，如果设置了 EX 参数，Redis 会计算出过期时间并存储在键的过期字典中。
GET 命令的底层实现流程
GET 命令执行时，Redis 首先根据键在字典中查找对应的字符串对象。如果找到，Redis 根据字符串对象的内部编码来获取值。如果是 int 编码，直接返回整数；如果是 embstr 或 raw 编码，从相应的内存位置读取字符串内容并返回。如果键不存在，直接返回 nil。
SET 和 GET 命令的常见问题与解决方案
键冲突问题
在实际应用中，可能会出现键冲突的情况，即不同的业务模块使用了相同的键名。为了避免键冲突，可以采用以下策略：
命名空间：在键名前加上业务模块的前缀。例如，用户模块的键可以以 user: 开头，订单模块的键可以以 order: 开头。这样即使不同模块有相同的子键名，也不会冲突。例如，user:user1:name 和 order:order1:customer_name。
使用哈希表：对于一组相关的数据，可以使用哈希表来存储，而不是使用多个独立的键。例如，对于用户的多个属性，可以使用一个哈希表 user:user1，其中包含 name、age、email 等字段，而不是使用 user:user1:name、user:user1:age 等多个键。
数据一致性问题
在使用 Redis 作为缓存时，可能会出现数据一致性问题。例如，当数据库中的数据更新后，Redis 缓存中的数据没有及时更新，导致客户端获取到的是旧数据。
缓存更新策略：
- 先更新数据库，再更新缓存：这种策略简单直接，但在并发情况下可能会出现问题。例如，在更新数据库后但还未更新缓存时，另一个请求读取数据，会读到旧的缓存数据。
- 先删除缓存，再更新数据库：这种策略也存在问题。在高并发场景下，可能会出现缓存删除后，多个请求同时查询数据库并将旧数据写回缓存的情况。
- 先更新数据库，再删除缓存：这种策略相对较为常用。在更新数据库成功后，删除 Redis 中的缓存数据。当下次请求获取数据时，由于缓存不存在，会从数据库读取最新数据并重新缓存。不过，在极端情况下，如删除缓存失败，还是可能会出现数据不一致问题，这时候可以结合重试机制或者使用消息队列来确保缓存被正确删除。
不同编程语言中使用 SET 和 GET 命令的示例
Python
我们已经在前面的示例中展示了很多 Python 使用 Redis SET 和 GET 命令的代码。下面再总结一下基本的使用方式：
import redis
r = redis.Redis(host='localhost', port=6379, db=0)
# SET 操作
r.set('key1', 'value1')
# GET 操作
value = r.get('key1')
if value:
print(value.decode('utf-8'))
Java
在 Java 中使用 Jedis 库来操作 Redis：
import redis.clients.jedis.Jedis;
public class RedisExample {
public static void main(String[] args) {
Jedis jedis = new Jedis("localhost", 6379);
// SET 操作
jedis.set("key2", "value2");
// GET 操作
String value = jedis.get("key2");
System.out.println(value);
jedis.close();
}
}
C#
使用 StackExchange.Redis 库在 C# 中操作 Redis：
using StackExchange.Redis;
using System;
class Program
{
static void Main()
{
var connectionMultiplexer = ConnectionMultiplexer.Connect("localhost:6379");
var db = connectionMultiplexer.GetDatabase();
// SET 操作
db.StringSet("key3", "value3");
// GET 操作
var value = db.StringGet("key3");
if (value.HasValue)
{
Console.WriteLine(value);
}
connectionMultiplexer.Close();
}
}
通过以上对 Redis 字符串命令 SET 和 GET 的深入解析，我们了解了它们的基本用法、应用场景、底层实现以及常见问题的解决方案。在实际开发中，合理运用 SET 和 GET 命令，可以充分发挥 Redis 的高性能优势，提升系统的整体性能和稳定性。无论是缓存数据、实现分布式锁还是应对其他复杂的业务需求，这两个命令都是 Redis 应用的重要基础。