• Redis-五种数据类型

    Redis基本特性

    a) 非关系型的键值对数据库，可以根据键以O(1) 的时间复杂度取出或插入关联值

    b) Redis 的数据是存在内存中的

    c) 键值对中键的类型可以是字符串，整型，浮点型等，且键是唯一的

    d) 键值对中的值类型可以是string，hash，list，set，sorted set 等

    e) Redis 内置了复制，磁盘持久化，LUA脚本，事务，SSL, ACLs，客户端缓存，客户端代理等功能（6.0新特性）

    f) 通过Redis 哨兵和Redis Cluster 模式提供高可用性

    Redis应用场景

    a) 计数器 可以对 String 进行自增自减运算，从而实现计数器功能。Redis 这种内存型数据库的读写性能非常高，很适合存储频繁读写的计数量。

    b) 分布式ID生成 利用自增特性，一次请求一个大一点的步长如 incr 2000 ,缓存在本地使用，用完再请求。

    c) 海量数据统计 位图（bitmap）:存储是否参过某次活动，是否已读谋篇文章，用户是否为会员， 日活统计。

    d) 会话缓存 可以使用 Redis 来统一存储多台应用服务器的会话信息。当应用服务器不再存储用户的会话信息，也就不再具有状态，一个用户可以请求任意一个应用服务器，从而更容易实现高可用性以及可伸缩性。

    e) 分布式队列/阻塞队列 List 是一个双向链表，可以通过 lpush/rpush 和 rpop/lpop 写入和读取消息。可以通过使用brpop/blpop 来实现阻塞队列。

    f) 分布式锁实现 在分布式场景下，无法使用基于进程的锁来对多个节点上的进程进行同步。可以使用 Redis 自带的 SETNX 命令实现分布式锁。

    g) 热点数据存储 最新评论，最新文章列表，使用list 存储，ltrim取出热点数据，删除老数据。

    h) 社交类需求 Set 可以实现交集，从而实现共同好友等功能，Set通过求差集，可以进行好友推荐，文章推荐。

    i) 排行榜 sorted_set可以实现有序性操作，从而实现排行榜等功能。

    j) 延迟队列 使用sorted_set，使用 【当前时间戳 + 需要延迟的时长】做score, 消息内容作为元素,调用zadd来生产消息，消费者使用zrangbyscore获取当前时间之前的数据做轮询处理。消费完再删除任务 rem key member

    Redis 的key 都是字符串（SDS， simple dynamic string）类型，命令由客户端发送给服务端都会转换为字节流的形式，虽然看起来可能是数字、浮点数、或者字符串多种类型

    1. > set 1 a // 数字key
    2. > get 1
    3.  
    4. > set 0.5 b // 浮点key
    5. > get 0.5
    6.  
    7. > set a c // 字符串key
    8. > get a
    9.  
    10. 以上key 发送到服务端最终都是以字节流的形式

    SDS 的特点：

    a）二进制安全的数据结构，安全体现在不会丢数据（c：char data[]="g\0ao"，C 语言以"\0" 作为字符串结尾标记，业务数据存在"\0"时存在安全问题）

    b）内存预分配机制，防止频繁扩容产生的内存分配问题

    c）兼容C语言的函数库

    扩容示例：

    1. redis:
    2.   sds:
    3.     free: 0
    4.     len: 3
    5.     char buf[]="gao" -> "gao123"
    6.     
    7.     len: 3
    8.     addlen: 3
    9.     (len + addlen) * 2 = 12  //扩容，(现有长度+需要增加长度)*2
    10.     // 成倍扩容，当长度len=1024，再扩容每次增加1M，(所以使用 setbit 设置大点的空间，防止频繁扩容)
    11.     
    12.   append，setbit 
    13.     sds:
    14.       free: 6
    15.       len: 6
    16.       char buf[]="gao123"

    设计思想：

    1. K-V：map -> dict，
    2. 数据库：海量数据的存储
    3. 1、数组：O(1) 随机访问，下表
    4. 2、链表：O(n) 头结点，遍历
    5. 3、数：log(n) 优化的比较好的场景，二分查找
    6.     
    7. hash(key) 任意数据进行随机散列，并且把hash 值转换为一个自然数[大]
    8. 创建一个大的数组：arr[4]
    9. hash(key) -> 自然数[大] % 4 = [0, arr.size-1], redis 就是这么干的
    10. 1、任意相同的输入，一定能得到相同的输出
    11. 2、不同的输入，可能得到相同的输出
    12. 把现实中无限的数据放到有限的集合中，肯定会产生hash 冲突    
    13. (k1,v1),(k2,v2),(k3,v3)
    14.     
    15. hash(k1) % 4 = 0
    16. hash(k2) % 4 = 1
    17.     
    18. arr[0]->(k1,v1,next->null)
    19. arr[1]->(k3,v3,next->k2)(k2,v2,next->null)
    20. 产生hash 冲突时，redis 使用的是头插法
    21. redis 是比较基础的语言，没有那么多高级特性，没有那么多工具可以用，是redis 作者自己实现的
    22. 通过链表法来解决碰撞，java 中的hashMap 要复杂得多
    23.  
    24. key：string
    25. value：string，hash，list，set，sorted set

    Redis之String 类型数据结构直通车

    Redis6.0 多线程，但是最终执行用户请求是在单线程中进行的，渐进式扩容很有必要

    有趣命令：

    1. > type [key] //查看key的类型
    2. string
    3. > object encoding 100 //key 所对应的值，在redis 底层是一个什么样的编码格式
    4. "int"
    5. > object encoding str
    6. "embstr"
    7. > object encoding 0.1
    8. "int"
    9.     
    10. int / embstr 都是redis 对内存方面的优化

    Redis求模小优化：

    1. 任意数 % 2^n //对CPU 不友好，累除法
    2. 任意数 & (2^n - 1) //一次位运算

    Redis 对于值是string 类型的底层编码结构分析：

    1. //type [key]，查看key 的类型
    2. //object encoding [key]，查值在底层的编码格式
    3.  
    4. //redis 中所有对象的封装
    5. typedef struct redisObject {    
    6.   unsigned type:4; //约束客户端命令，当前类型。位域的语法，占4个bit 位
    7.   unsigned encoding:4; //编码格式，同样占4个bit 位
    8.   unsigned lru:LRU_BITS; //24个bit 位，也就是3 个字节
    9.   int refcount; //引用计数法，4个字节
    10.   void *ptr; //数据真正存放的位置，8个字节
    11. } robj;
    12.  
    13.  
    14. redisObject 占16个字节的空间
    15. cache line：64字节，64 - 16 = 48 字节，肯定可以利用起来
    16. 48个字节使用sdshdr8的数据结构存储，因为48在数据范围 2^5 ~ 2^8-1 之间
    17.  
    18. struct __attribute__ ((__packed__)) sdshdr8 {  // 表示 2^5 ~ 2^8-1 的数据    
    19.     uint8_t len; /* used */    
    20.     uint8_t alloc; /* excluding the header and null terminator */    
    21.     unsigned char flags; /* 3 lsb of type, 5 unused bits */    
    22.     char buf[];
    23. };
    24.  
    25. sds本身消耗4个字节，其中len、alloc、flags各占一个字节，另外'\0'占一个字节，因为兼容C语言的函数库
    26. 最终：48 - 4 = 44 字节，用来存放实际的数据

    对于string 类型的value 有结论如下：

    1. value 值是string 类型的底层编码结构：
    2. 1、value值的长度小于等于20，尝试转换成数字转换成功，底层使用int 编码格式
    3. 2、value值不满足条件1，且长度小于等于44redis 底层使用embstr 编码结构
    4. 3、value值不满足1和2条件，使用row 编码结构也就是sds 的数据结构，简单动态字符串

    扩展分析：

    1. 亿级日活的统计：
    2.  
    3. bit 的特点，除了0 就是1，所以可以用1个bit 位表示登陆状态
    4. 像这样1个字节就可以表示8个用户
    5.  
    6.        1 1 0 1 0 1 0 1 1 1 0 1 0 0 1 0 1   -- 登陆状态
    7. offset:0 1 2 3 4 5 6 7 8 9 ...
    8.  
    9. 命令：setbit key offset 0|1   
    10. 日期可以作为一个key 使用，“2022-5-26”
    11.  
    12. 变种：userId 是数字时，可以作为偏移量使用
    13. setbit a-bit-map userId 1
    14. setbit a-bit-map userId 1
    15.  
    16. getbit a-bit-map 8
    17. userId:
    18. bit: 0/1 (默认值是0)

    简单测试：

    1. > setbit login_05_26 100 1
    2. > setbit login_05_26 100 1
    3. > setbit login_05_26 100 1
    4.  
    5. > getbit login_05_26 100  //获取日期5月26日用户100的活跃状态，id特别大可以减固定值优化
    6.  
    7. > setbit login_05_26 100 0 //恢复状态
    8. > getbit login_05_26 100
    9.  
    10. > STRLEN login_05_26 //长度13 字节。100/8bit = 12.5 所以分配13个字节
    11. > type login_05_26 //string 类型的数据
    12. > get login_05_26 //可以执行命令，获取的数据是内存中的存储，没有实际意义
    13.  
    14.  
    15. > setbit login_05_26 100 1
    16. > setbit login_05_26 101 1
    17. > setbit login_05_26 102 1
    18. > setbit login_05_26 103 1
    19.  
    20. > BITCOUNT login_05_26 //统计bit位是1的个数：4
    21. > strlen login_05_26 //13个字节
    22. > BITCOUNT login_05_26 0 12 //一共13个字节，从索引0开始，所以是0和12。可以统计一部分数据根据索引
    23.  
    24. string 表示数据最大是512M，索引位是2^32-1。最多可表示这么多的用户
    25.

    另一个扩展分析：

    1. login_05_26: 0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 1
    2. login_05_27: 1 1 0 1 0 1 0 1 1 1 0 1 0 0 1 0 1
    3. 连续登陆情况：按位与再统计
    4. > BITOP and login_05_26-27 login_05_26 login_05_27 //按位与操作，结果存到login_05_26-27中
    5. > BITCOUNT login_05_26-27 //再做一次bitcount可以得到连续登陆的结果
    6.  
    7. login_05_24: 0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 1
    8. login_05_25: 1 1 0 1 0 1 0 1 1 1 0 1 0 0 1 0 1
    9. login_05_26: 0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 1
    10. login_05_27: 1 1 0 1 0 1 0 1 1 1 0 1 0 0 1 0 1
    11. login_05_28: 0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 1
    12. login_05_29: 1 1 0 1 0 1 0 1 1 1 0 1 0 0 1 0 1
    13. login_05_30: 0 1 0 1 0 1 1 1 0 1 0 1 1 0 0 1 1
    14. 周活：按位或，有一天登陆就行
    15. > BITOP or login_05_26-27-active login_05_26 login_05_27 //两天内有一天登陆就行
    16. > BITCOUNT login_05_26-27-active
    17.     
    18. redis 源码有判断只能是0或1，按位与 按位或，效率非常高
    19. 汉明重量 按位操作 有兴趣的同学可以了解

    List常用API

    1. /> help @list
    2.  
    3. LPUSH key element [element ...]
    4. RPOP key
    5. RPUSH key element [element ...]
    6. LPOP key
    7. BLPOP key [key ...] timeout
    8. BRPOP key [key ...] timeout
    9. BRPOPLPUSH source destination timeout
    10. RPOPLPUSH  source destination
    11. LINDEX key index
    12. LLEN key
    13. LINSERT key BEFORE|AFTER pivot element
    14. LRANGE key start stop
    15. LREM key count element
    16. LSET key index element
    17. LTRIM key start stop

    List是一个有序(按加入的时序排序)的数据结构，Redis采用quicklist（双端链表） 和 ziplist 作为List的底层实现。

    可以通过设置每个ziplist的最大容量，quicklist的数据压缩范围，提升数据存取效率

    1. list-max-ziplist-size  -2        //  单个ziplist节点最大能存储  8kb  ,超过则进行分裂,将数据存储在新的ziplist节点中
    2. list-compress-depth  1        //  0 代表所有节点，都不进行压缩，1， 代表从头节点往后走一个，尾节点往前走一个不用压缩，其他的全部压缩，2，3，4 ... 以此类推

    Redis - quicklist 数据结构：

    Redis - ziplist 数据结构：

    Hash常用API

    1. /> help  @hash 
    2.  
    3. HSET key field value [field value ...]
    4. HGET key field
    5. HMGET key field [field ...]
    6. HKEYS key
    7. HGETALL key
    8. HVALS key
    9. HEXISTS key field
    10. HDEL key field [field ...]
    11. HINCRBY key field increment
    12. HINCRBYFLOAT key field increment
    13. HLEN key
    14. HSCAN key cursor [MATCH pattern] [COUNT count]
    15. HSETNX key field value
    16. HSTRLEN key field

    Hash 数据结构底层实现为一个字典( dict )，也是RedisBb用来存储K-V的数据结构,当数据量比较小，或者单个元素比较小时，底层用ziplist存储，数据大小和元素数量阈值可以通过如下参数设置。

    1. hash-max-ziplist-entries  512    //  ziplist 元素个数超过 512 ，将改为hashtable编码 
    2. hash-max-ziplist-value    64      //  单个元素大小超过 64 byte时，将改为hashtable编码

    Redis - hash 数据结构：

    Set常用API

    1. /> help  @set
    2.  
    3. SADD key member [member ...]              
    4. SCARD key                                                 
    5. SISMEMBER key member
    6. SPOP key [count]
    7. SDIFF key [key ...]
    8. SINTER key [key ...]
    9. SUNION key [key ...]
    10. SMEMBERS key
    11. SRANDMEMBER key [count]
    12. SREM key member [member ...]
    13. SMOVE source destination member
    14. SUNIONSTORE destination key [key ...]
    15. SDIFFSTORE destination key [key ...]
    16. SINTERSTORE destination key [key ...]
    17. SSCAN key cursor [MATCH pattern] [COUNT count]

    Set 为无序的，自动去重的集合数据类型，Set 数据结构底层实现为一个value 为 null 的 字典( dict )，当数据可以用整形表示时，Set集合将被编码为intset数据结构。两个条件任意满足时 Set将用hashtable存储数据。1， 元素个数大于 set-max-intset-entries , 2 ， 元素无法用整形表示 

    set-max-intset-entries 512       // intset 能存储的最大元素个数，超过则用hashtable编码

    Redis - set 数据结构：

    ZSet常用API

    1. /> help  @sorted_set
    2.  
    3. ZADD key [NX|XX] [CH] [INCR] score member [score member ...]
    4. ZCARD key
    5. ZCOUNT key min max
    6. ZINCRBY key increment member
    7. ZRANGE key start stop [WITHSCORES]
    8. ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
    9. ZRANK key member
    10. ZREM key member [member ...]
    11. ZREMRANGEBYRANK key start stop
    12. ZREMRANGEBYSCORE key min max
    13. ZREVRANGE key start stop [WITHSCORES]
    14. ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]
    15. ZREVRANK key member
    16. ZSCAN key cursor [MATCH pattern] [COUNT count]
    17. ZSCORE key member

    ZSet 为有序的，自动去重的集合数据类型，ZSet 数据结构底层实现为 字典(dict) + 跳表(skiplist) ，当数据比较少时，用ziplist编码结构存储。 

    1. zset-max-ziplist-entries  128    // 元素个数超过128 ，将用skiplist编码
    2. zset-max-ziplist-value     64     //  单个元素大小超过 64 byte, 将用 skiplist编码

    Redis - zset 数据结构：

    Redis - skiplist 数据结构：

  • 相关阅读:
    【华为机试真题 Python实现】比较两个版本号的大小
    【面试普通人VS高手系列】请说一下你对分布式锁的理解，以及分布式锁的实现
    day7【代码随想录】移除链表元素
    【nginx】Nginx配置：
    VScode配置Ros环境
    链表面试题-刷题
    RCNN 目标检测网络学习笔记 （附代码）
    【红队】要想加入红队，需要做好哪些准备？
    9.WPF资源
    java并发编程：synchronized同步方法
  • 原文地址：https://blog.csdn.net/weixin_58482311/article/details/134541594