【Redis笔记】一起学习Redis | 大海捞针，了解scan命令

本文链接：https://blog.csdn.net/snailmann/article/details/97615456

一起学习Redis | 大海捞针，了解scan命令

如果觉得对你有帮助，能否点个赞或关个注，以示鼓励笔者呢？！博客目录 | 先点这里

前提概要
- 了解一下keys命令
- 为什么要使用scan代替keys
Scan命令
- scan衍生类型
- scan基本使用
- scan的遍历原理
代码实践
- scan命令
- hscan命令
- sscan命令
- zscan命令

前提概要

了解一下keys命令

在平时线上的Redis维护过程中，有时候需要从Redis实例中的成千上万个key中找到特定前缀的key集合。可能是批量删除，也可能是批量修改，查询等等。这样就延伸出了一个问题，如何从海量的key中找到满足特定前缀的数据集合？

keys pattern
Redis提供了一个简单粗暴的keys命令来列出所有满足特定正则字符串规则的key

虽然keys命令非常的简单，但是有点过度简单，并且带有两个明显的缺点：

不支持offset, limit功能，既没有分批查询的功能
如果在海量数据的Redis实例中，如果满足条件的查询有上百万，千万的key，那么该查询操作会非常的耗时。
keys命令是线性遍历，时间复杂度是O(n)
如果符合条件的数据过多，鉴于Redis的单线程模型，该命令会严重阻塞其他客户端在该Redis实例的命令操作。所以keys不适合在生产环境中使用。

为什么要使用scan代替keys

所以Redis为了解决Keys存在缺陷的这个问题，在2.8版本后加入了scan的命令。那么scan命令相比keys有什么好处呢？

虽然scan复杂度也是O(n) ，但是我的原理是游标分步遍历，提供分批的功能，一次只查一部分。不会对线程造成严重阻塞。
提供了count的参数，类似于limit功能，可以限制一次最多返回的近似最大值

在这里插入图片描述

scan最重要的特性就是可以分批操作，不会一个命令执行很长时间，从而导致阻塞线程。虽然scan有如此多的好处，但是它的操作相对keys而言更为复杂，而且也有几个缺点需要注意

返回的结果可能会有重复，需要用户自己去重
遍历的过程，如果有数据改动，改动后的数据是否能够查到是不能确定的

Scan命令

scan衍生类型

Redis的四种基本容器类型中，只有hash,set,zset支持scan操作，list没有scan操作

针对所有Redis的外部键

scan

针对Redis容器类型的键

hscan
sscan
zscan

scan基本使用

命令参数

scan 
   
   
    
    cursor
   
    [MATCH pattern] [COUNT count]

cursor就是游标，第一次查询，游标默认为0。只有当scan返回的游标再次为0，才代表本次整体遍历结束
pattren就是字符串匹配规则
count就是近视的最大要返回的元素个数，并不严苛，但是大致会在count的范围浮动

如何使用

一般我们可以在代码上封装好分批查询，既要多次调用scan命令，每次都将上次scan返回的游标结果作为下次scan的游标参数。
第一次scan的游标默认为0，在整体的遍历中，只有当之后的某次scan返回的游标结果再次为0，这代表本次整体循环结束。

scan特性

单次返回的结果，如果为空，不代表就遍历结束了。只有其返回的游标是空，才代表此次遍历结束
可能会返回重复的结果
每次遍历的数据个数，或多或少，但最大个数肯定在count参数的附近，除非哈希冲突的个数太多了。

scan的遍历原理

在Redis中所有的key都存储在一个很大的字典中，这个字典的结构和Java的HashMap一样。通过一维数组来存储数据，哈希冲突的数据使用链地址法来解决。

在这里插入图片描述

而scan指令是怎么遍历这个数组和链表的呢？

scan中的cursor游标实际代表的就是数组的位置索引，Redis将这个位置索引称之为槽(slot)。在不考虑字典扩容的情况下。scan就是按照数组的下标，一个一个遍历槽的。而scan返回游标就是代表此时遍历到数组的这个位置，如要下次遍历，就从这里开始。
count并不是要遍历的元素个数，而是一次scan，要遍历的槽的个数，既遍历数组的长度是多少。
之所以有时候返回的数据多，有的时候数据少，甚至有的时候，数据为空。这是因为并不是数组的每个槽都存放有数据的。如果有多个冲突数据，这会存在这个槽的链表中。

代码实践

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()

hscan命令

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()

sscan命令

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()

zscan

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()