如果觉得对你有帮助,能否点个赞或关个注,以示鼓励笔者呢?!博客目录 | 先点这里
在平时线上的Redis维护过程中,有时候需要从Redis实例中的成千上万个key中找到特定前缀的key集合。可能是批量删除,也可能是批量修改,查询等等。这样就延伸出了一个问题,如何从海量的key中找到满足特定前缀的数据集合?
keys pattern
虽然keys命令非常的简单,但是有点过度简单,并且带有两个明显的缺点:
不支持offset, limit功能,既没有分批查询的功能
如果在海量数据的Redis实例中,如果满足条件的查询有上百万,千万的key,那么该查询操作会非常的耗时。
keys命令是线性遍历,时间复杂度是O(n)
如果符合条件的数据过多,鉴于Redis的单线程模型,该命令会严重阻塞其他客户端在该Redis实例的命令操作。所以keys不适合在生产环境中使用。
所以Redis为了解决Keys存在缺陷的这个问题,在2.8版本后加入了scan的命令。 那么scan命令相比keys有什么好处呢?
scan最重要的特性就是可以分批操作,不会一个命令执行很长时间,从而导致阻塞线程。虽然scan有如此多的好处,但是它的操作相对keys而言更为复杂,而且也有几个缺点需要注意
Redis的四种基本容器类型中,只有hash,set,zset支持scan操作,list没有scan操作
针对所有Redis的外部键
scan
针对Redis容器类型的键
hscan
sscan
zscan
命令参数
scan
cursor
[MATCH pattern] [COUNT count]
如何使用
scan特性
在Redis中所有的key都存储在一个很大的字典中,这个字典的结构和Java的HashMap一样。通过一维数组来存储数据,哈希冲突的数据使用链地址法来解决。
而scan指令是怎么遍历这个数组和链表的呢?
cursor游标
实际代表的就是数组的位置索引,Redis将这个位置索引称之为槽(slot)。在不考虑字典扩容的情况下。scan就是按照数组的下标,一个一个遍历槽的。而scan返回游标就是代表此时遍历到数组的这个位置,如要下次遍历,就从这里开始。count
并不是要遍历的元素个数,而是一次scan,要遍历的槽的个数,既遍历数组的长度是多少。import redis
"""
验证scan命令
"""
client = redis.StrictRedis(host='127.0.0.1', port=6379)
key = "test:"
def set_data():
"""
(1) 插入1000个string类型key
"""
for i in range(1000):
client.set(key + str(i), i)
def scan_data():
"""
(2) 通过scan遍历这1000个“test:”前缀的数据
"""
cursor = 0 # 游标起始为0
sum_number = 0 # 元素总量,验证数量
while True:
data = client.scan(cursor, key + '*', 100)
cursor = data[0]
sum_number += len(data[1])
if cursor == 0: # 只要游标变回0,代表遍历结束
break
print(len(data[1]), list(map(
lambda
key: key.decode('utf-8'), data[1])))
print(str(sum_number))
def del_data():
"""
(3) 通过scan删除这1000个“test:”前缀开头的数据
"""
cursor = 0 # 游标起始为0
while True:
data = client.scan(cursor, key + '*', 100)
cursor = data[0]
keys = list(map(
lambda
key: key.decode('utf-8'), data[1]))
client.delete(*keys)
if cursor == 0: # 只要游标变回0,代表遍历结束
break
if __name__ == '__main__':
"""
1. 插入1000个数据
2. 通过scan遍历这1000个数据
3. 通过scan分批删这个1000个数据,每批扫描100个数据槽,大致10批
4. 再次通过scan查询这1000个数据,看是否删除成功
"""
set_data()
scan_data()
del_data()
scan_data()
import redis
"""
验证hscan命令
"""
client = redis.StrictRedis(host='127.0.0.1', port=6379)
outer_key = "
hash
"
hash_key = "test:"
def hset_data():
"""
(1) 对"
hash
"的键插入1000个哈希子数据
"""
for i in range(1000):
client.hset(outer_key, hash_key + str(i), i)
def hscan_data():
"""
(2) 通过hscan遍历这1000个“test:”前缀的子数据
"""
cursor = 0 # 游标起始为0
sum_number = 0 # 元素总量,验证数量
while True:
data = client.hscan(outer_key, cursor, hash_key + '*', 100)
cursor = data[0]
sum_number += len(data[1])
if cursor == 0: # 只要游标变回0,代表遍历结束
break
print(len(data[1]), list(map(
lambda
key: key.decode('utf-8'), data[1])))
print(str(sum_number))
def hdel_data():
"""
(3) 通过hscan删除这1000个“test:”前缀开头的子数据
"""
cursor = 0 # 游标起始为0
while True:
data = client.hscan(outer_key, cursor, hash_key + '*', 100)
cursor = data[0]
keys = list(map(
lambda
key: key.decode('utf-8'), data[1]))
client.hdel(outer_key, *keys)
if cursor == 0: # 只要游标变回0,代表遍历结束
break
if __name__ == '__main__':
"""
1. 向hash类型的"
hash
"键插入1000个子数据
2. 通过hscan遍历"
hash
"键的1000个子数据
3. 通过hscan分批删这个1000个子数据,每批扫描100个数据槽,大致10批
4. 再次通过hscan查询这1000个数据,看是否删除成功
"""
hset_data()
hscan_data()
hdel_data()
hscan_data()
import redis
"""
验证sscan命令
"""
client = redis.StrictRedis(host='127.0.0.1', port=6379)
outer_key = "set"
data_prefix = "set:"
def sadd_data():
"""
(1) 对"set"的键插入1000个集合子数据,所有集合内容皆以“set:”开头
"""
for i in range(1000):
client.sadd(outer_key, data_prefix + str(i))
def sscan_data():
"""
(2) 通过sscan遍历set键集合的1000个“set:”前缀的子数据
"""
cursor = 0 # 游标起始为0
sum_number = 0 # 元素总量,验证数量
while True:
data = client.sscan(outer_key, cursor, data_prefix + '*', 100)
cursor = data[0]
sum_number += len(data[1])
if cursor == 0: # 只要游标变回0,代表遍历结束
break
print(len(data[1]), list(map(
lambda
set_data: set_data.decode('utf-8'), data[1])))
print(str(sum_number))
def srem_data():
"""
(3) 通过sscan分批删除这1000个“set:”前缀开头的集合数据
"""
cursor = 0 # 游标起始为0
while True:
data = client.sscan(outer_key, cursor, data_prefix + '*', 100)
cursor = data[0]
datas = list(map(
lambda
set_data: set_data.decode('utf-8'), data[1]))
client.srem(outer_key, *datas)
if cursor == 0: # 只要游标变回0,代表遍历结束
break
if __name__ == '__main__':
"""
1. 向set类型的"set"键插入1000个子数据
2. 通过sscan遍历"set"键的1000个子数据
3. 通过sscan分批删这个1000个子数据,每批扫描100个数据槽,大致10批
4. 再次通过sscan查询这1000个数据,看是否删除成功
"""
sadd_data()
sscan_data()
srem_data()
sscan_data()
import redis
"""
验证sscan命令
"""
client = redis.StrictRedis(host='127.0.0.1', port=6379)
outer_key = "zset"
data_prefix = "zset:"
def zadd_data():
"""
(1) 对"zset"的键插入1000个有序集合子数据,所有集合内容皆以“zset:”开头
"""
for i in range(1000):
item = {
data_prefix + str(i): i
}
client.zadd(outer_key, item)
def zscan_data():
"""
(2) 通过zscan遍历zset键有序集合的1000个“zset:”前缀的子数据
"""
cursor = 0 # 游标起始为0
sum_number = 0 # 元素总量,验证数量
while True:
data = client.zscan(outer_key, cursor, data_prefix + '*', 100)
cursor = data[0]
sum_number += len(data[1])
if cursor == 0: # 只要游标变回0,代表遍历结束
break
zset_tuple = data[1]
print(len(data[1]), list(map(
lambda
zset_data: zset_data[0].decode('utf-8'), zset_tuple)))
print(str(sum_number))
def zrem_data():
"""
(3) 通过zscan分批删除这1000个“zset:”前缀开头的有序集合数据
"""
cursor = 0 # 游标起始为0
while True:
data = client.zscan(outer_key, cursor, data_prefix + '*', 100)
cursor = data[0]
zset_tuple = data[1]
datas = list(map(
lambda
zset_data: zset_data[0].decode('utf-8'), zset_tuple))
client.zrem(outer_key, *datas)
if cursor == 0: # 只要游标变回0,代表遍历结束
break
if __name__ == '__main__':
"""
1. 向zset类型的"zset"键插入1000个子数据
2. 通过zscan遍历"zset"键的1000个子数据
3. 通过zscan分批删这个1000个子数据,每批扫描100个数据槽,大致10批
4. 再次通过zscan查询这1000个数据,看是否删除成功
"""
zadd_data()
zscan_data()
zrem_data()
zscan_data()
大key数据,每次的set, get, del都是需要花费大量的时间。所以我们需要对这些大key的数据进行分批操作
针对容器类型的大key , 比如hash, list, set, zset
等,我们都可以考虑使用分批操作,比如删除操作:
Large Hash Key
可使用hscan命令,每次获取500个字段,再用hdel命令,每次500个内部元素。Large Set Key
可使用sscan命令,每次扫描集合中500个元素,再用srem命令每次删除500个元素。Large List Key
可通过ltrim命令每次删除部分元素,直到全部删除Large Sorted Set Key
使用zset自带的zremrangebyrank命令,每次删除前500个元素《Redis深度历险》
redis过期键删除策略以及大key删除方法 - @作者:konami
如果觉得对你有帮助,能否点个赞或关个注,以示鼓励笔者呢?!