02 Redis数据结构基础

一.客户端命令行参数

  • 1.-x 从标准输入读取一个参数,等价于set k v

    [[email protected] etc]# echo -en ‘v1‘|redis-cli -a foobared -x set k1
    OK
    [[email protected] etc]# redis-cli -a foobared get k1
    "v1"
  • 2.-r 重复执行一个命令指定次数
    [[email protected] etc]# redis-cli -a foobared -r 2 get k1
    "v1"
    "v1"
  • 3.-i 命令执行间隔
    [[email protected] etc]# redis-cli -a foobared -r 2 -i 3 get k1
    "v1"
    "v1"
  • 4.-rdb 获取指定实例的rdb文件,保存到本地
    [[email protected] etc]# redis-cli -a foobared --rdb /tmp/6379.rdb
    SYNC sent to master, writing 263 bytes to ‘/tmp/6379.rdb‘
    Transfer finished with success.
    [[email protected] etc]# ls -l /tmp/6379.rdb
    -rw-r--r--. 1 root root 263 Jun 14 13:34 /tmp/6379.rdb
  • 5.-scan-pattern 用scan命令扫描redis中的key,pattern是匹配模式,相比keys pattern模式好处在于不会长时间阻塞redis而导致其他客户端命令请求被阻塞
    [[email protected] etc]# redis-cli -a foobared --scan --pattern ‘*1‘
    k1
    [[email protected] etc]# redis-cli -a foobared --scan --pattern ‘*1*‘
    k10
    k1
    [[email protected] etc]# redis-cli -a foobared --scan --pattern ‘k*‘
    k10
    k2
    k1
  • 6.连接参数
    redis-cli -a password -h hostname/IP -p port
    redis-cli -s socketfile
  • 7.socket参数默认不开启unixsocket /tmp/redis.sock,且同样需要输入密码
    [[email protected] tmp]# redis-cli -s /tmp/redis.sock
    redis /tmp/redis.sock>
    redis /tmp/redis.sock> keys k1
    (error) NOAUTH Authentication required.
    redis /tmp/redis.sock> auth foobared
    OK
    redis /tmp/redis.sock> keys *
    1) "k10"
    2) "bit"
    3) "k1"
    4) "k2"
  • 8.-stat 获取redis诊断数据
    [[email protected] tmp]# redis-cli -a foobared --stat
    ------- data ------ --------------------- load -------------------- - child -
    keys       mem      clients blocked requests            connections  #
    308087     28.90M   51      0       308649 (+0)         58
    432618     37.45M   51      0       433641 (+124992)    58
    552107     53.65M   51      0       553683 (+120042)    58
    673106     57.96M   51      0       675476 (+121793)    58
    797567     66.51M   51      0       800856 (+125380)    58
    921655     75.03M   51      0       925951 (+125095)    58
    995100     77.12M   1       0       1000101 (+74150)    58
    995100     77.12M   1       0       1000102 (+1)        58
    995100     77.12M   1       0       1000103 (+1)        58
    995100     77.12M   1       0       1000104 (+1)        58
    1004507    80.71M   51      0       1009652 (+9548)     108
    1119911    104.64M  51      0       1126280 (+116628)   108
    1227279    112.01M  51      0       1234913 (+108633)   108          # 

    redis-benchmark -a foobared -h 127.0.0.1 -p 6379 -t set -n 1000000 -r 100000000

  • 9.-bigkeys 对redis中的key进行采样,寻找较大的keys,根据采样得出大概的数据统计
    [[email protected] bin]# redis-cli -a foobared --bigkeys
    #
    # Scanning the entire keyspace to find biggest keys as well as
    # average sizes per key type.  You can use -i 0.1 to sleep 0.1 sec
    # per 100 SCAN commands (not usually needed).
    #
    [00.00%] Biggest string found so far ‘key:000036007278‘ with 3 bytes
    [50.49%] Sampled 1000000 keys so far
    [51.97%] Biggest string found so far ‘bit‘ with 1261 bytes
    #
    -------- summary -------
    #
    Sampled 1980449 keys in the keyspace!
    Total key length in bytes is 31687130 (avg len 16.00)
    #
    Biggest string found ‘bit‘ has 1261 bytes
    #
    1980449 strings with 5942603 bytes (100.00% of keys, avg size 3.00)
    0 lists with 0 items (00.00% of keys, avg size 0.00)
    0 sets with 0 members (00.00% of keys, avg size 0.00)
    0 hashs with 0 fields (00.00% of keys, avg size 0.00)
    0 zsets with 0 members (00.00% of keys, avg size 0.00)
  • 10.-latency 获取命令的请求响应延迟时间,单位是毫秒
    [[email protected] bin]# redis-cli -a foobared --latency
    min: 0, max: 16, avg: 1.31 (5697 samples)

二.数据结构类型

  • key:只有string类型
  • values:string、set、list、hash、zset
    结构类型 结构存储的值 结构的读写能力
    string 字符串、整数、浮点数、任何二进制格式的数据 对整字符串和部分进行操作,对整数和浮点数执行自增或者自建操作
    list 一个链表,链表的每个字节都包含一个字符串 链表两端推出或弹出元素;根据偏移量对链表进行修剪;读取单个或者多个元素;根据值查找或者移除元素
    set 包含字符串的无序收集器,每个字符串不重复 添加、获取、移除单个元素;检查一个元素是否存在;计算交、并、差集;从集合中随机取元素
    hash 包含键值对的无序散列表 添加、获取、移除多个键值对;获取所有键值对
    zset 字符串成员member与浮点数分值score之间的有序映射,元素的排序有分值大小决定 获取、添加、移除单个元素;根据分值范围或者成员来获取元素
1.string
1.1 SET key value [EX seconds] [PX milliseconds] [NX|XX]
  • EX 代表设置超时时间,单位为秒
  • PX 代表设置超时时间,单位为毫秒
  • NX 代表只有key不存在才设置值
  • XX 代表只有key存在才更新值
  • 如果成功,返回ok,失败则返回nil
    127.0.0.1:6379> set kk1 vv1 EX 2
    OK
    127.0.0.1:6379> get kk1
    "vv1"
    127.0.0.1:6379> get kk1
    (nil)
    127.0.0.1:6379> set kk1 vv1 PX 2000
    OK
    127.0.0.1:6379> get kk1
    "vv1"
    127.0.0.1:6379> get kk1
    (nil)
    127.0.0.1:6379> set kk1 100 NX
    OK
    127.0.0.1:6379> get kk1
    "100"
    127.0.0.1:6379> set kk2 100 XX
    (nil)
    127.0.0.1:6379> set kk1 200 XX
    OK
    127.0.0.1:6379> get kk1
    "200"
    127.0.0.1:6379> set kk1 300 NX
    (nil)
1.2 MGET KEY1 KEY2...
  • 返回指定的key的值,如果key不存在则返回这个key的值为nil
  • 返回指定key的值列表
    127.0.0.1:6379> mget k1 kk1
    1) "v1"
    2) "200"
    127.0.0.1:6379> mget k1
    1) "v1"
    127.0.0.1:6379> mget k1 kk1 kk2
    1) "v1"
    2) "200"
    3) (nil)
1.3 MSET KEY1 VALUE1 KEY2 VALUE2 ...
  • 设置多个k/v,如果某个key已经存在,则被覆盖
  • 原子性操作
  • 不想覆盖现有值,用msetnx
  • 总是返回ok,此操作不会失败
    127.0.0.1:6379> mset k1 v1 k2 v2
    OK
    127.0.0.1:6379> mget k1 k2
    1) "v1"
    2) "v2"
    127.0.0.1:6379> mset k1 v1 k2 v2 k3
    (error) ERR wrong number of arguments for MSET
1.4 MSETNX k1 v1 k2 v2...
  • 只要一个k存在,结果失败
  • 返回1表示成功,0表示失败
    127.0.0.1:6379> mset k2 v2 k3 v3
    OK
    127.0.0.1:6379> msetnx k3 v3 k4 v4
    (integer) 0
    127.0.0.1:6379> msetnx k4 v4 k5 v5
    (integer) 1
1.5 append
  • 如果k存在,并且是string类型,就把新值追加到末尾,相当于字符串拼接
  • 如果k不存在,类似set功能
  • 返回字符长度
    127.0.0.1:6379> get k6
    (nil)
    127.0.0.1:6379> append k6 123
    (integer) 3
    127.0.0.1:6379> get k6
    "123"
    127.0.0.1:6379> append k6 abc
    (integer) 6
    127.0.0.1:6379> get k6
    "123abc"
1.6 incr key
  • 对值进行+1操作,必须是integer类型
  • 最大值为64位有符号值
  • 返回值为加完的结果
    127.0.0.1:6379> mset k1 v1 k2 2.2 k3 3
    OK
    127.0.0.1:6379> incr k1
    (error) ERR value is not an integer or out of range
    127.0.0.1:6379> incr k2
    (error) ERR value is not an integer or out of range
    127.0.0.1:6379> incr k3
    (integer) 4
1.7 decr key
  • 对值减一操作,必须是int类型
  • 如果key不存在,会对key赋值为0,在做操作
  • 上下限为64位有符号值
  • 返回操作后的结果值
    127.0.0.1:6379> mget k1 k2 k3
    1) "v1"
    2) "2.2"
    3) "4"
    127.0.0.1:6379> decr k1
    (error) ERR value is not an integer or out of range
    127.0.0.1:6379> decr k2
    (error) ERR value is not an integer or out of range
    127.0.0.1:6379> decr k3
    (integer) 3
    127.0.0.1:6379> mset k01 -1
    OK
    127.0.0.1:6379> decr k01
    (integer) -2
    127.0.0.1:6379> decr k100
    (integer) -1
    127.0.0.1:6379> get 100
    (nil)
1.8 decrby key decrment、incrby key increment
  • 对值进行加减操作,步长为decrement,必须是int
  • 返回操作后的结果
    127.0.0.1:6379> mset k1 10 k2 20
    OK
    127.0.0.1:6379> decrby k1 2
    (integer) 8
    127.0.0.1:6379> incrby k2 2
    (integer) 22
    127.0.0.1:6379> mget k1 k2
    1) "8"
    2) "22"
1.8 incrbyfloat key increment
  • 浮点型加操作,可以是int
  • 返回操作后的结果
    127.0.0.1:6379> mset k1 1.1 k2 2.2 k3 3
    OK
    127.0.0.1:6379> incrbyfloat k1 2.2
    "3.3"
    127.0.0.1:6379> decrbyfloat k2 1.1
    (error) ERR unknown command ‘decrbyfloat‘
    127.0.0.1:6379> incrbyfloat k3 1
    "4"
1.9 strlen key
  • 对字符串取长

    127.0.0.1:6379> strlen k1
    (integer) 3
1.10 getrange key start end
  • 按索引取子串
  • 索引为负表示末尾取
    127.0.0.1:6379> set k1 abcdefg
    OK
    127.0.0.1:6379> getrange k1 0 1
    "ab"
    127.0.0.1:6379> getrange k1 -2 -1
    "fg"
1.11 get bit key offset
  • 获取一个字符串类型key指定位置的二进制位的值(0/1),索引从0开始

    127.0.0.1:6379> get k1
    "abcdefg"
    127.0.0.1:6379> getbit k1 0
    (integer) 0
    127.0.0.1:6379> getbit k1 1
    (integer) 1
    127.0.0.1:6379> getbit k1 2
    (integer) 1
    127.0.0.1:6379> getbit k1 3
    (integer) 0
    127.0.0.1:6379> getbit k1 4
    (integer) 0
1.12 setbit key offset value
  • 设置字符串类型建指定位置的二进制位的值,返回该位置的旧值

    127.0.0.1:6379> setbit k1 0 1
    (integer) 0
    127.0.0.1:6379> getbit k1 0
    (integer) 1
1.13 bitcount
  • 取字符串类型键中值时1的二进制位的个数

    127.0.0.1:6379> bitcount k1
    (integer) 27
    127.0.0.1:6379> get k1
    "\xe1bcdefg"
2.lists
2.1 lpush key value ...
  • 把所有值从list的头部插入,如果key不存在就创建一个空的队列
  • 如果key对应的value不是list类型,报错
  • 元素从左往右插入
  • 返回list的长度
    127.0.0.1:6379> get list1
    (nil)
    127.0.0.1:6379> lpush list1 1 2 3
    (integer) 3
    127.0.0.1:6379> get list1
    (error) WRONGTYPE Operation against a key holding the wrong kind of value
2.2 lpush key value
  • 从list头部插入一个值,key不存在不产生插入动作
  • 返回list的长度
    127.0.0.1:6379> lpush list1 1 2 3
    (integer) 3
    127.0.0.1:6379> lpush list1 4
    (integer) 4
  • 存储顺序如4 3 2 1
2.3 lpop
  • 弹出一个元素,最左边先弹出
  • 返回被弹出元素
    127.0.0.1:6379> lpop list1
    "4"
    127.0.0.1:6379> lpop list1
    "3"
    127.0.0.1:6379> lpop list1
    "2"
    127.0.0.1:6379> lpop list1
    "1"
    127.0.0.1:6379> lpop list1
    (nil)
2.4 rpop
  • 右边弹出,并返回被弹出元素

    127.0.0.1:6379> lpush list1 1 2 3
    (integer) 3
    127.0.0.1:6379> rpop list1
    "1"
    127.0.0.1:6379> rpop list1
    "2"
    127.0.0.1:6379> rpop list1
    "3"
    127.0.0.1:6379> rpop list1
    (nil)
2.5 blpop key [keyn] timeout / brpop
  • 以阻塞方式从key中弹出并返回第一个值,只弹出和返回第一个非空的key

    127.0.0.1:6379> lpush list1 1 2 3
    (integer) 3
    127.0.0.1:6379> blpop list1 2
    1) "list1"
    2) "3"
    127.0.0.1:6379> blpop list1 list2 2
    1) "list1"
    2) "2"
  • timeout 阻塞时长,单位是秒,0表示一直阻塞
  • 只要list的长度为0或者或者key不存在就会则色
  • 当多个key时,如blpop key1 key1,只要有一个key对应的list不是非空,则不会阻塞
  • 返回值依次包含key弹出的值阻塞的时长
  • 超时时,如果没有值可返回,则返回nil
    127.0.0.1:6379> blpop list1 2
    (nil)
    (3.01s)
    127.0.0.1:6379> lpush list1 1 2 3
    (integer) 3
    127.0.0.1:6379> blpop list1 2
    1) "list1"
    2) "3"
2.6 llen key
  • 求列表长度,不存在或者为空,返回0

    127.0.0.1:6379> llen list1
    (integer) 0
    127.0.0.1:6379> lpush list1 1 2 3
    (integer) 3
    127.0.0.1:6379> llen list1
    (integer) 3
2.7 rpush key valuen 多值插入
  • 右边插入,插入顺序即所得顺序
  • 返回list长度
    127.0.0.1:6379> rpush list1 a b c
    (integer) 6
    127.0.0.1:6379> rpop list1
    "c"
2.8 rpush key value 单值插入
  • 右边插入,不存在则不产生动作
  • 返回list长度
    127.0.0.1:6379> rpushx list1 b
    (integer) 6
    127.0.0.1:6379> rpushx list2 a
    (integer) 0
2.9 rpoplpush source destination
  • 原子性操作
  • 从souce尾部/右边移除一个值,并加入到destination指定的头部/左边
  • 如果source的list不存在,则返回nil,不做任何操作
  • 如果soure和destination是一样的,等价于右边移动到左边/尾部移动到头部
  • 返回被弹出和后插入的数据
    127.0.0.1:6379> rpush list1 a b c
    (integer) 3
    127.0.0.1:6379> rpush list2 1 2 3
    (integer) 3
    # 两个列表,分别是
    # list1 a b c
    # list2 1 2 3
    127.0.0.1:6379> rpoplpush list1 list2
    "c"
    # 第一个列表的尾部元素插入第二个列表头部
    # list1 a b
    # list2 c 1 2 3
    127.0.0.1:6379> rpop list2
    "3"
2.10 brpoplpush source destination timeout
  • 当source为空时,将会进行阻塞,timeout为0一直阻塞
2.11 lindex key index
  • 返回key指定的队列中的位置index的值
  • 0表示第一位,自后一位表示-1
    127.0.0.1:6379> rpop list1
    (nil)
    127.0.0.1:6379> lpush list1 a b c
    (integer) 3
    127.0.0.1:6379> lindex list1 0
    "c"
    127.0.0.1:6379> lindex list1 -1
    "a"
2.12 linsert key before|after pivot value
  • 插入value值在pivot值的前或者后
  • 如果key不存在,不产生动作
  • 如果pivot对应的值不存在则返回-1
  • 否则返回插入后list的长度
    127.0.0.1:6379> linsert list1 before b value1
    (integer) 4
    127.0.0.1:6379> lrange list1 0 3
    1) "c"
    2) "value1"
    3) "b"
    4) "a"
    127.0.0.1:6379> linsert list1 before d value1
    (integer) -1
2.13 lrange key start stop
  • 返回list元素,从左到右
  • 如果start大于stop,返回空
  • 如果stop大于list长度,返回所有元素
    127.0.0.1:6379> lrange list1 3 0
    (empty list or set)
    127.0.0.1:6379> lrange list1 0 100
    1) "c"
    2) "value1"
    3) "b"
    4) "a"
2.14 lrem key count value
  • 删除值等于value的count个元素
  • 如果count大于0,则从头到尾数
  • 如果count小于0,则从尾到头数
  • 如果count等于0,则删除所有值等于value的元素
    127.0.0.1:6379> lpush list5 1 2 2 1 3 5
    (integer) 6
    127.0.0.1:6379> lrange list5 0 100
    1) "5"
    2) "3"
    3) "1"
    4) "2"
    5) "2"
    6) "1"
    127.0.0.1:6379> lrem list5 0 5
    (integer) 1
    127.0.0.1:6379> lrange list5 0 100
    1) "3"
    2) "1"
    3) "2"
    4) "2"
    5) "1"
    127.0.0.1:6379> lrem list5 1 1
    (integer) 1
    127.0.0.1:6379> lrange list5 0 100
    1) "3"
    2) "2"
    3) "2"
    4) "1"
    127.0.0.1:6379> lrem list5 -1 2
    (integer) 1
    127.0.0.1:6379> lrange list5 0 100
    1) "3"
    2) "2"
    3) "1"
2.15 lset key index value
  • 修改key对应的list中,位置为index的元素值为value
  • 当index超过list的长度,将会出错
    127.0.0.1:6379> lrange list5 0 100
    1) "3"
    2) "2"
    3) "1"
    127.0.0.1:6379> lset list5 0 33
    OK
    127.0.0.1:6379> lrange list5 0 100
    1) "33"
    2) "2"
    3) "1"
    127.0.0.1:6379> lset list5 3 33
    (error) ERR index out of range
3.keys
3.1 del keyn
  • 删除指定key,如果key不存在,操作被忽略
  • 返回被删除的key个数
    127.0.0.1:6379> del list5 list1
    (integer) 2
    127.0.0.1:6379> lrange list5 0 100
    (empty list or set)
    127.0.0.1:6379> set k1 v1
    OK
    127.0.0.1:6379> set k2 v2
    OK
    127.0.0.1:6379> set k3 v3
    OK
    127.0.0.1:6379> del k1
    (integer) 1
    127.0.0.1:6379> del k2 k3
    (integer) 2
3.2 dump key
  • 按照rdb格式把指定key的值序列化返回给客户端,此序列化里面不包括ttl信息
  • 序列化的值中包含校验码
  • 不同版本的rdb可能存在差异
  • key不存在就返回nil
    127.0.0.1:6379> set k1 abcd123
    OK
    127.0.0.1:6379> dump k1
    "\x00\aabcd123\b\x00\x1b\xb1\xbc|\rG\xda\xeb"
    127.0.0.1:6379> del k1
    (integer) 1
    127.0.0.1:6379> restore k1 10 "\x00\aabcd123\b\x00\x1b\xb1\xbc|\rG\xda\xeb"
    OK
    127.0.0.1:6379> get k1
    (nil)
    127.0.0.1:6379> get k1
    (nil)
    127.0.0.1:6379> restore k1 0 "\x00\aabcd123\b\x00\x1b\xb1\xbc|\rG\xda\xeb"
    OK
    127.0.0.1:6379> get k1
    "abcd123"
3.3 restore key ttl serialized-value [REPLACE]
  • 恢复被序列化的key值
  • key已存在,不在replace覆盖属性,会报错
  • 成功返回ok
    127.0.0.1:6379> restore k1 0 "\x00\aabcd123\b\x00\x1b\xb1\xbc|\rG\xda\xeb"
    (error) BUSYKEY Target key name already exists.
    127.0.0.1:6379> restore k1 0 "\x00\aabcd123\b\x00\x1b\xb1\xbc|\rG\xda\xeb" replace
    OK
3.3 exists keyn
  • 判断key是否存在,存在则+1
  • 如果key重复,返回值会重复判断和+1
    127.0.0.1:6379> get k1
    "abcd123"
    127.0.0.1:6379> get k2
    (nil)
    127.0.0.1:6379> exists k1
    (integer) 1
    127.0.0.1:6379> exists k1
    (integer) 1
    127.0.0.1:6379> exists k1 k1
    (integer) 2
    127.0.0.1:6379> exists k2
    (integer) 0
3.3 expire key seconds
  • 设置超时时间,单位是秒,达到超时时间后,key被删除
  • 超时属性只能被del、set、getset和*store命令修改或者改变,其他命令不会改变超时属性
  • persist持久化取消超时设置
  • 当key被rename命令修改后,超时属性依然存在
  • 设置成功返回1,key不存在或者超时设置失败返回0
    127.0.0.1:6379> set k1 v1
    OK
    127.0.0.1:6379> set k1 v1 10
    (error) ERR syntax error
    127.0.0.1:6379> expire k1 2
    (integer) 1
    127.0.0.1:6379> get k1
    "v1"
    127.0.0.1:6379> get k1
    (nil)
    127.0.0.1:6379> set k1 v1 5
    (error) ERR syntax error
    127.0.0.1:6379> get k1
    (nil)
    127.0.0.1:6379> set k1 v1
    OK
    127.0.0.1:6379> expire k1 5
    (integer) 1
    127.0.0.1:6379> set k1 v2
    OK
    127.0.0.1:6379> get k1
    "v2"
    127.0.0.1:6379> get k1
    "v2"
    127.0.0.1:6379> get k1
    "v2"
    127.0.0.1:6379> get k1
    "v2"
    127.0.0.1:6379> set k1 v1
    OK
    127.0.0.1:6379> expire k1 10
    (integer) 1
    127.0.0.1:6379> persist k1
    (integer) 1
    127.0.0.1:6379> get k1
    "v1"
3.4 persist key
  • 持久化key,移除过期时间
  • 1表示成功,0表示key不存在或者key没有设置超时设置
    127.0.0.1:6379> persist k100
    (integer) 0
    127.0.0.1:6379> set k1 v1
    OK
    127.0.0.1:6379> persist k1
    (integer) 0
3.5 expireat key timestamp
  • 设置过期时间为精确时间戳
  • 1表示成功,0表示key不存在或者key没有设置超时设置
    127.0.0.1:6379> set k1 v1
    OK
    127.0.0.1:6379> expireat k1 1528965035
    (integer) 1
    127.0.0.1:6379> get k1
    "v1"
    127.0.0.1:6379> get k1
    "v1"
    # 1528965035 2018-06-14 16:30:35
    127.0.0.1:6379> set k1 v1
    OK
    127.0.0.1:6379> expireat k1 1528965035
    (integer) 1
    127.0.0.1:6379> get k1
    "v1"
    127.0.0.1:6379> get k1
    "v1"
    127.0.0.1:6379> get k1
    "v1"
    127.0.0.1:6379> get k1
    "v1"
    127.0.0.1:6379> get k1
    (nil)
3.6 keys pattern
  • 返回符合匹配key的所有values
  • 会造成阻塞影响性能,可以用scan护着sets代替查找
  • *表示任意字符,?表示单个字符,[ae]代表a或者b
  • [^e]排除e,[a-d]代表a,b,c,d
    127.0.0.1:6379> mset a 1 b 2 c 3 d 4
    OK
    127.0.0.1:6379> keys [a-c]
    1) "a"
    2) "c"
    3) "b"
    (0.58s)
3.7 ttl key
  • 返回生存时间
  • key不存在,返回-2
  • key没有超时设置,返回-1
    127.0.0.1:6379> set k 1 ex 10
    OK
    127.0.0.1:6379> set k2 2
    OK
    127.0.0.1:6379> ttl k
    (integer) 1
    127.0.0.1:6379> ttl k2
    (integer) -1
    127.0.0.1:6379> ttl k3
    (integer) -2
3.8 pttl key
  • 返回的是毫秒生存时间

    127.0.0.1:6379> set k1 v1 EX 100
    OK
    127.0.0.1:6379> pttl k1
    (integer) 97195
3.9 SCAN cursor [MATCH pattern] [COUNT count]
  • 基于游标方式范湖当前数据的key,因为每次返回的数据不多,也不会阻塞服务器,可以在生产中使用
  • coursor表示游标的位置,一般从0开始,返回数据中的第一行代表的就是下一次游标的位置,当返回的下一行游标是0时,代表本次迭代完成;此游标不是一个连续标准值,比如5,10,15是连续标准
  • MATCH pattern类似keys中的模式一样,返回匹配模式的迭代游标
  • Count代表每次迭代返回的数据条数,默认是10,只是一个提示,实现时并没有严格保证,实际返回的值可能会比这个值多一些,但是不糊多太多
  • 与keys或者smembers命令,scan返回的结果是不稳定的,在执行迭代的过程中,如果key发生变化,不弱删除或者新增,则返回的结果可能存在以下几个问题
  • 可能会返回重复的key,所有使用此命令时,业务系统需要判断重复
  • 如果迭代过程中,有key被删除了,但是迭代完成前没有被添加进来,则此key并不会出现在迭代中
    127.0.0.1:6379> scan 0
    1) "5505024"
    2)  1) "key:000051260311"
    2) "key:000036007278"
    3) "key:000059694484"
    4) "key:000006587804"
    5) "key:000004199401"
    6) "key:000094197164"
    7) "key:000099600200"
    8) "key:000051222239"
    9) "key:000075613120"
       10) "key:000058266859"
       11) "key:000076128079"
    127.0.0.1:6379> scan 10
    1) "1835018"
    2)  1) "key:000075289699"
    2) "key:000078347835"
    3) "key:000071808967"
    4) "key:000066680858"
    5) "key:000020401759"
    6) "key:000087370174"
    7) "key:000089373903"
    8) "key:000094725692"
    9) "key:000077304879"
       10) "key:000019052151"
    127.0.0.1:6379> scan 20
    1) "7077908"
    2)  1) "key:000005041067"
    2) "key:000045121774"
    3) "key:000095755193"
    4) "key:000006008892"
    5) "key:000041833711"
    6) "key:000064230555"
    7) "key:000074550342"
    8) "key:000084491604"
    9) "key:000096452813"
       10) "key:000094200031"
    127.0.0.1:6379> scan  0 count 20
    1) "1179648"
    2)  1) "key:000051260311"
    2) "key:000036007278"
    3) "key:000059694484"
    4) "key:000006587804"
    5) "key:000004199401"
    6) "key:000094197164"
    7) "key:000099600200"
    8) "key:000051222239"
    9) "key:000075613120"
       10) "key:000058266859"
       11) "key:000076128079"
       12) "key:000051853542"
       13) "key:000091156937"
       14) "key:000072767835"
       15) "key:000026187737"
       16) "key:000083167013"
       17) "key:000057492750"
       18) "key:000027269441"
       19) "key:000012211723"
       20) "key:000058915500"
    127.0.0.1:6379> scan 0 match key:00005126031*
    1) "5505024"
    2) 1) "key:000051260311"
    127.0.0.1:6379> scan 0 match 1*
    1) "5505024"
    2) (empty list or set)
4.hashes
4.1 hset key filed value
  • key代表的是一个hash表,field为hash的表的key,value为hash表中key对应的value
  • 如果key不存在,则创建一个key及对应的hash表
  • 如果field存在,则把value覆盖原来的值
  • 如果field是新加入的,并且设置成功,则返回1
  • 如果field已经存在,成功更新旧值,返回0
    127.0.0.1:6379> hset dict1 name yzw
    (integer) 1
    127.0.0.1:6379> hset dict1 age 40
    (integer) 1
    127.0.0.1:6379> hset dict1 age 18
    (integer) 0
4.2 HMSET key fieldn valuen
  • 1次性设置多个值
  • 成功返回OK
    127.0.0.1:6379> HMSET map1 name yzw age 40
    OK
4.3 HSETNX key field value
  • key代表hash表
  • field代表hash表的key,value代表hash表对应key的value
  • 当field不存在时才设置
  • 如果field不存在,则设置值,返回1
  • 如果field存在,不做任何操作,返回0
    127.0.0.1:6379> hkeys dict1
    1) "name"
    2) "age"
    127.0.0.1:6379> hsetnx dict1 age 18
    (integer) 0
    127.0.0.1:6379> hsetnx dict1 addr gz
    (integer) 1
    127.0.0.1:6379> 
4.4 hkeys key
  • 获取key对应的map的所有key
  • 返回key列表
    127.0.0.1:6379> hkeys dict1
    1) "name"
    2) "age"
    3) "addr"
4.5 hlen key
  • 获取key对应的map的filed数量,也就是字典长度或者元素个数

    127.0.0.1:6379> hlen dict1
    (integer) 3
4.6 hget key field
  • 获取某个field的值
  • 如果key不存在或者field不存在,返回nil,否则返回值
    127.0.0.1:6379> hget dict1 name
    "yzw"
    127.0.0.1:6379> hget dict1 salary
    (nil)
    127.0.0.1:6379> hget ddd name
    (nil)
4.7 hmget key fieldn
  • 返回多个key对应的map值
  • 不存在返回nil
    127.0.0.1:6379> hmget dict1 name age addr salary
    1) "yzw"
    2) "18"
    3) "gz"
    4) (nil)
4.8 hstrlen key field
  • 返回field对应值的长度
  • 不存在返回0
    127.0.0.1:6379> hstrlen dict1 name
    (integer) 3
    127.0.0.1:6379> hstrlen dict1  salary
    (integer) 0
4.9 hdel key fieldn
  • 删除key对应的map的field,可以原子性删除多个
  • 返回删除的值的个数
    127.0.0.1:6379> hdel dict1 addr age
    (integer) 2
    127.0.0.1:6379> hmget dict1 name age addr
    1) "yzw"
    2) (nil)
    3) (nil)
4.10 hexists key field
  • 判断指定map中是否存在对应key
  • 如果key不存在或者filed不存在返回0
  • 否则返回1
    127.0.0.1:6379> hexists dict1 name
    (integer) 1
    127.0.0.1:6379> hexists dict1 age
    (integer) 0
4.11 hgetall key
  • 返回key对应的map的所有k/v对

    127.0.0.1:6379> hgetall dict1
    1) "name"
    2) "yzw"
4.12 hincrby key field increment
  • 对指定field加上increment,必须是int类型,64位有符号数
  • 返回增加后的结果,不存在则加入元素
    127.0.0.1:6379> hgetall dict1
    1) "name"
    2) "yzw"
    3) "age"
    4) "18"
    127.0.0.1:6379> hincrby dict1 age 2
    (integer) 20
    127.0.0.1:6379> hincrby dict1 salary 100
    (integer) 100
    127.0.0.1:6379> hgetall dict1
    1) "name"
    2) "yzw"
    3) "age"
    4) "20"
    5) "salary"
    6) "100"
4.13 hincrbyfloat key field increment
  • 浮点

    127.0.0.1:6379> hset dict1 salary 100.1
    (integer) 0
    127.0.0.1:6379> hgetall dict1
    1) "name"
    2) "yzw"
    3) "age"
    4) "20"
    5) "salary"
    6) "100.1"
    127.0.0.1:6379> hincrbyfloat dict1 salary 1
    "101.1"
    127.0.0.1:6379> hincrbyfloat dict1 salary 0.1
    "101.2"
4.14 hscan key cursor [MATCH pattern] [Count count]
  • 迭代hash里面的value值

    127.0.0.1:6379> hscan dict1 10
    1) "0"
    2) 1) "name"
       2) "yzw"
       3) "age"
       4) "20"
       5) "salary"
       6) "101.2"
    127.0.0.1:6379> hscan dict1 10 MATCH n*
    1) "0"
    2) 1) "name"
       2) "yzw"
    127.0.0.1:6379> hscan dict1 10 MATCH *a*
    1) "0"
    2) 1) "name"
       2) "yzw"
       3) "age"
       4) "20"
       5) "salary"
       6) "101.2"
    127.0.0.1:6379> hscan dict1 10 MATCH *a* COUNT 1
    1) "0"
    2) 1) "name"
       2) "yzw"
       3) "age"
       4) "20"
       5) "salary"
       6) "101.2"

二.举例说明list和hash的应用场景,每个至少一个场景,比如:通过list实现秒杀的请求排队

1.string
  • 实现MC的功能
  • 对字符串操作
  • 缓存应用k/V,计算数量
2.list
  • 关注列表、粉丝列表
  • 消息队列
  • 最top内容
3.hash
  • hash如json,存储非结构化数据
  • 如用户信息
4.set
  • 去重,分组
  • 如分数 优秀、良好、合格、不合格
5.zset
  • set内有序排序

原文地址:https://www.cnblogs.com/jenvid/p/9186601.html

时间: 2024-11-08 21:47:49

02 Redis数据结构基础的相关文章

redis 数据结构基础 (二) 链表

redis中的链表恐怕是最简单的数据结构了,redis链表中总共有3个数据结构: listNode: 1 typedef struct listNode { 2 struct listNode *prev; //前向节点指针 3 struct listNode *next; //后续节点指针 4 void *value; //存储的值,采取void*类型,万能类型,但是少了类型信息 5 } listNode; 从这个上面可以看出,redis的链表是双向链表 list: typedef struc

REdis数据结构服务器

Rdis和JQuery一样是纯粹为应用而产生的,这里记录的是在CentOS 5.7上学习入门文章: 1.Redis简介  Redis是一个key-value存储系统.和Memcached类似,但是解决了断电后数据完全丢失的情况,而且她支持更多无化的value类型,除了和string外,还支持lists(链表).sets(集合)和zsets(有序集合)几种数据类型.这些数据类型都支持push/pop.add/remove及取交集并集和差集及更丰富的操作,而且这些操作都是原子性的. 2.Redis的

Redis 数据结构之dict(2)

本文及后续文章,Redis版本均是v3.2.8 上篇文章<Redis 数据结构之dict>,我们对dict的结构有了大致的印象.此篇文章对dict是如何维护数据结构的做个详细的理解. 老规矩还是打开Redis的源码,文件dict.c 一.dict数据结构的维护 1.dictCreate - 创建一个新的哈希表 /* Reset a hash table already initialized with ht_init(). * NOTE: This function should only b

Redis数据结构之intset

本文及后续文章,Redis版本均是v3.2.8 上篇文章<Redis数据结构之robj>,我们说到redis object数据结构,其有5中数据类型:OBJ_STRING,OBJ_LIST, OBJ_SET,OBJ_ZSET,OBJ_HASH.集合对象set有着广泛的实际业务应用场景,它包含的元素无序并且不能重复及集合间的交.并.差等基础的操作.本篇就来说说Redis暴露给我们使用的set集合对象的底层实现-intset. 其实,可以理解为有序整型集合 intset是一个由整数组成的有序集合,

redis使用基础(二) ——Redis数据类型

redis使用基础(二) --Redis数据类型 (转载请附上本文链接--linhxx)  一.概述 Redis是一种Key-Value类型的数据库,属于非关系型数据库,NoSQL的一种.Redis共有5种数据类型:字符串(string).散列(hash).列表(list).集合(set).有序集合(zset). 1.通配符 Redis支持部分通配符,包括?.*.[].\x,和正则表达式一致,?表示匹配0或1个,*匹配任意个,[]匹配框内的任意一个内容,\x转义,例如\?表示匹配?. 2.获取键

redis学习(二) redis数据结构介绍以及常用命令

redis数据结构介绍 我们已经知道redis是一个基于key-value数据存储的数据结构数据库,这里的key指的是string类型,而对应的value则可以是多样的数据结构.其中包括下面五种类型: 1.string 字符串 string字符串类型是redis最基础的数据存储类型.string是最基础的一种数据类型,其可以拓展为某种特定类型,例如普通文本,json字符串,二进制数据等等.就本质上来说,接下来要介绍的hash,list,set等其内部最基础的组成单位依然是string,只不过re

算法数据结构02 /常用数据结构

目录 2算法数据结构02 /常用数据结构 1. 栈 2. 队列 3. 双端队列 4. 内存相关 5. 顺序表 6. 链表 7. 二叉树 2算法数据结构02 /常用数据结构 1. 栈 特性:先进后出的数据结构,有栈顶和栈尾 应用场景:每个 web 浏览器都有一个返回按钮.浏览网页时,这些网页被放置在一个栈中(实际是网页的网址).现在查看的网页在顶部,第一个查看的网页在底部.如果按'返回'按钮,将按相反的顺序浏览刚才的页面. 栈的方法: Stack():创建一个空的新栈. 它不需要参数,并返回一个空

02 java语言基础

常量:字面值常量(字符串,字符,整数,小数,布尔,null),自定义常量,''这个不是字符常量,""这个是字符串常量 进制: 02.01_Java语言基础(常量的概述和使用)(掌握) A:什么是常量 在程序执行的过程中其值不可以发生改变 B:Java中常量的分类 字面值常量 自定义常量(面向对象部分讲) C:字面值常量的分类 字符串常量 用双引号括起来的内容 整数常量 所有整数 小数常量 所有小数 字符常量 用单引号括起来的内容,里面只能放单个数字,单个字母或单个符号 布尔常量 较为特

数据结构基础总结

数据的逻辑结构 数据的存储结构 单链表是递归结构 迭代是指从当前元素获得集合中的后继元素. 迭代功能由Tterable可迭代接口和Tterator迭代器接口实现. 栈和队列 是两种特殊的线性表,特殊之处在于插入和删除操作的位置受到限制. 栈:插入和删除只允许在线性表的一端进行,后进先出. 队列:插入和删除分别在线性表的两端进行,先进先出. 数组: 1.数组是随机存取结构,这是数组最大的优点. 2.数组一旦占用一片存储空间,这片存储空间的地址和长度就确定的,不能更改,因此数组只能进行赋值.取值两种