【云原生进阶之PaaS中间件】第一章Redis-1.2数据类型

1 Redis 数据类型

Redis支持五种数据类型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。

1.1 String（字符串）

string是redis最基本的类型，你可以理解成与Memcached一模一样的类型，一个key对应一个value。string类型是二进制安全的。意思是redis的string可以包含任何数据。比如jpg图片或者序列化的对象 。string类型是Redis最基本的数据类型，一个键最大能存储512MB。

1.1.1 使用示例

redis 127.0.0.1:6379> SET name "redis.net.cn"OK
redis 127.0.0.1:6379> GET name"redis.net.cn"

在以上实例中我们使用了 Redis 的 SET 和 GET 命令。键为 name，对应的值为redis.net.cn。

注意：一个键最大能存储512MB。

1.1.2 内部实现解析

string类型的内部实现，其本质是一个byte数组：

struct sdshdr {    
    long len; //buf数组的长度    
    long free; //buf数组中剩余可用字节数    
    char buf[]; //存储实际字符串内容
}

  String 采用预分配冗余空间的方式来减少内存的频繁分配，内部为当前字符串实际分配的空间 capacity 一般要高于实际字符串长度 len。当字符串长度小于 1M 时，扩容都是加倍现有的空间，如果超过 1M，扩容时一次只会多扩 1M 的空间。需要注意的是字符串最大长度为 512M。

1.1.3 高阶运用

键值对

> set name codehole
OK
> get name
"codehole"
> exists name
(integer) 1
> del name
(integer) 1
> get name
(nil)

批量键值对  

可以批量对多个字符串进行读写，节省网络耗时开销

> set name1 codehole
OK
> set name2 holycoder
OK
> mget name1 name2 name3 
# 返回一个列表
1) "codehole"
2) "holycoder"
3) (nil)
> mset name1 boy name2 girl name3 unknow
> mget name1 name2 name3
1) "boy"
2) "girl"
3) "unknown"

过期和 set 命令扩展

  可以对 key 设置过期时间，到点自动删除，这个功能常用来控制缓存的失效时间。不过这个 [自动删除] 的机制是比较复杂的。

> set name codehole
> get name
"codehole"
> expire name 5 # 5s 后过期
... # wait for 5s

> get name
(nil)

> setex name 5 codehole # 5s 后过期，等价于 set + expire

> get name
"codehole"

... # wait for 5s

> get name

(nil)

> setnx name codehole # set 和 expire 原子执行，因为 name 不存在就执行创建成功
(integer) 1

> get name
"codehole"

> setnx name holycoder #  set 和 expire 原子执行，因为 name 存在 set 创建不成功
(integer) 0

> get name
"codehole"

计数  

如果 value 值是一个整数，还可以对它进行自增操作。自增是有范围的，它的范围是 signed long 的最大最小值，超过了这个值，Redis 会报错。

> set age 30
OK
> incr age
(integer) 31
> incrby age 5
(integer) 36
> incrby age -5
(integer) 31
> set codehole 9223372036854775807
# Long.Max
Ok

  字符串是由多个字节组成，每个字节又是由 8 个 bit 组成，如此便可以将一个字符串看成很多 bit 的组合，这便是 bitmap「位图」数据结构。

1.2 Hash（哈希）

Redis hash 是一个键值对集合。Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。

1.2.1 实例

redis 127.0.0.1:6379> HMSET user:1 username redis.net.cn password redis.net.cn points 200
OK
redis 127.0.0.1:6379> HGETALL user:1
1) "username"
2) "redis.net.cn"
3) "password"
4) "redis.net.cn"
5) "points"
6) "200"
redis 127.0.0.1:6379>

以上实例中 hash 数据类型存储了包含用户脚本信息的用户对象。 实例中我们使用了 Redis HMSET, HEGTALL 命令，user:1 为键值。每个 hash 可以存储 2^32 - 1 键值对（40多亿）。

1.2.2 Hash 底层数据结构

hash的底层存储有两种数据结构：

• ziplist：如果hash对象保存的键和值字符串长度都小于64字节且hash对象保存的键值对数量小于512，则采用这种；

• dict（字典）：其他情况采用这种数据结构；

  hash 结构也可以用来存储用户信息，不同于字符串一次性需要全部序列化整个对象，hash 以对用户结构中的每个字段单独存储。这样当我们需要获取用户信息时可以进行部分获取。而以整个符串的形式去保存用户信息的话就只能一次性全部读取，这样就会比较浪费网络流量。

  hash 也有缺点，hash 结构的存储消耗要高于单个字符串，到底该使用 hash 还是字符串，需要根据实际情况再三权衡。

1.2.2.1 ziplist

 上图中可以看到，当数据量比较小的时候，我们会将所有的key及value都当成一个元素，顺序的存入到ziplist中，构成有序。

1.2.2.2 dict（字典）

字典结构定义：

typedef struct dict {
    // 类型特定函数
    dictType *type;
    // 私有数据
    void *privdata;

    // 哈希表，两个元素
    dictht ht[2]
    // rehash时记录的索引下标，当没有rehash时，值为-1
    int rehashidx;
} dict;

其中，哈希表dictht 的结构定义为：

typedef struct dictht {
    // 哈希表数组
    dictEntry **table;
 
    // 哈希表大小
    unsigned long size;

    // 哈希表大小掩码，用于计算索引值
    unsigned long sizenask;
 
    // 该哈希表已有节点的数量
    unsigned long uesd;
} dictht;

图示结构如下：

  Redis的字典相当于Java语言里面的HashMap，它是无序字典。内部实现结构上同 Java 的 HashMap 也是一致的，同样的数组 + 链表二维结构。第一维 hash 的数组位置碰撞时，就会将碰撞的元素使用链表串接起来。

  不同的是，Redis 的字典的值只能是字符串，另外它们 rehash 的方式不一样，因为Java 的 HashMap 在字典很大时，rehash 是个耗时的操作，需要一次性全部 rehash。Redis为了高性能，不能堵塞服务，所以采用了渐进式 rehash 策略。

1.2.3 渐进式 rehash

  渐进式 rehash 会在 rehash 的同时，保留新旧两个 hash 结构，查询时会同时查询两个 hash 结构，然后在后续的定时任务中以及 hash 的子指令中，循序渐进地将旧 hash 的内容一点点迁移到新的 hash 结构中。

  当 hash 移除了最后一个元素之后，该数据结构自动被删除，内存被回收。

1.2.3.1 渐进式 rehash 详细步骤

为 ht[1] 分配空间，让dict字典同时持有 ht[0] 和 ht[1] 两个哈希表。

在字典中维持一个索引计数器变量 rehashidx，并将它的值设置为0，表示 rehash 工作正式开始。

在 rehash 进行期间，每次对字典执行添加、删除、查找或者更新操作时，程序除了执行指定的操作以外，还会顺带将 ht[0] 哈希表在 rehashidx 索引(table[rehashidx]桶上的链表)上的所有键值对 rehash 到 ht[1] 上，当 rehash 工作完成之后，将 rehashidx 属性的值增一，表示下一次要迁移链表所在桶的位置。

随着字典操作的不断执行，最终在某个时间点上，ht[0] 的所有桶对应的键值对都会被 rehash 至 ht[1]，这时程序将 rehashidx 属性的值设为-1，表示 rehash 操作已完成。

  渐进式 rehash 的好处在于它采取分而治之的方式， 将 rehash 键值对所需的计算工作均滩到对字典的每个添加、删除、查找和更新操作上， 从而避免了集中式 rehash 而带来的庞大计算量。

1.2.4 基本操作命令

> hset books java "thinks in java"  
# books 是 key，Java 是 hash中的 key
# 如果 字符串包含空格 要用引号括起来
(integer) 1

> hset books golang "concurrency in go"
(integer) 1

> hgetall books  
# entries()，key 和 value 间隔出现
1) "java"
2) "thinks in java"
3) "golang"
4) "concurrency in go"

> hlen books
(integer) 2

> hget books golang
"concurrency in go"

> hset books golang "learning go programming" 
# 因为是更新操作，所以返回 0
(integer) 0

> hget books golang
"learning go programming"

> hmset books java "effective java" golang "modern golang
programming"  # 批量 set
OK

同字符串一样，hash 结构中的单个子 key 也可以进行计数，它对应的指令是 hincrby，和 incr 使用基本一样。

> hincrby user-laoqian age 1
(integer) 30

1.3 List（列表）

Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素导列表的头部（左边）或者尾部（右边）。

1.3.1 实例

redis 127.0.0.1:6379> lpush redis.net.cn redis
(integer) 1
redis 127.0.0.1:6379> lpush redis.net.cn mongodb
(integer) 2
redis 127.0.0.1:6379> lpush redis.net.cn rabitmq
(integer) 3
redis 127.0.0.1:6379> lrange redis.net.cn 0 10
1) "rabitmq"
2) "mongodb"
3) "redis"
redis 127.0.0.1:6379>

列表最多可存储 2^32 - 1 元素 (4294967295, 每个列表可存储40多亿)。

1.3.2 高阶运用

Redis 的列表相当于 Java 语言里面的 LinkedList，注意它是链表而不是数组，而且是双向链表。这意味着 list 的插入和删除操作非常快，时间复杂度为 O(1)，但是索引定位很慢，时间复杂度为O(n)，这点让人非常意外。

  当列表弹出了最后一个元素之后，该数据结构自动被删除，内存被回收。

  Redis 的列表结构常用来做异步队列使用。将需要延后处理的任务结构体序列化成字符串塞进 Redis 的列表，另一个线程从这个列表中轮询数据进行处理。

右边进左边出：队列

> rpush books python java golang
(integer) 3

> llen books
(integer) 3

> lpop books
"python"

> lpop books
"java"

> lpop books
"golang"

> lpop books
(nil)

右边进右边出：栈

> rpush books python java golang
(integer) 3

> rpop books
"golang"

> rpop books
"java"

> rpop books
"python"

> rpop books
(nil)

慢操作

  lindex 相当于 java 链表的 get(int index)方法，它需要对链表进行遍历，性能随着参数 index 增大而变差。ltrim 和字面上的含义不太一样，个人觉得它叫 lretain(保留) 更适合一些，因为 ltrim 跟两个参数 start_index 和 end_index 定义了一个区间，在这个区间内的值，ltrim 是要保留，区间之外统统砍掉。我们可以通过 ltrim 来实现一个定长的链表，这一点非常有用。index 可以为负数，index=-1 表示倒数第一个元素，同样 index=-2 表示倒数第二个元素。

> rpush books python java golang
(integer) 3

> lindex books 1 # O(n) 慎用，并不会删除 "java"
"java"

> lrange books 1 -1 # 获取从1开始到最后一个元素，O(n) 慎用, 并不会删除
1) "python"
2) "java"
3) "golang"

> ltrim books 1 -1 # O(n) 慎用
OK

> lrange books 0 -1 # 获取所有元素
1) "java"
2) "golang"

> ltrim books 1 0 # 这其实是清空了整个列表，因为区间范围长度为负
OK

> llen books
(integer) 0

1.4 Set（集合）

Redis的Set是string类型的无序集合。Set 底层用两种数据结构存储：

• intset：如果元素个数少于默认值512且元素可以用整型，则用这种数据结构

• dict（字典）：其他情况采用这种数据结构

  当集合中最后一个元素移除之后，数据结构自动删除，内存被回收。set 结构可以用来存储活动中奖的用户 ID，因为有去重功能，可以保证同一个用户不会中奖两次。

集合是通过哈希表实现的，所以添加、删除、查找的复杂度都是O(1)。

1.4.1 intset 定义

typedef struct intset {
    // 编码类型
    uint32_t encoding;
    // 集合包含的元素数量
    uint32_t length;
    // 保存元素的数组
    int8_t contents[];
} intset;

集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。

1.4.2 基本操作命令

主要操作命令sadd，添加一个string元素到,key对应的set集合中，成功返回1,如果元素以及在集合中返回0,key对应的set不存在返回错误。

> sadd books python
(integer) 1

> sadd books python # 重复
(integer) 0

> sadd books golang
(integer) 1

> smembers books  # 注意顺序，和插入的并不一致，因为 set 是无序的
1) "golang"
2) "python"


> sismember books python # 查询某个 value 是否存在，相当于 contains(o)
(integer) 1

> sismember books rust
(integer) 0

> scard books # 获取长度相当于 count()
(integer) 2

> spop books # 弹出一个
"python"

1.5 zset(sorted set：有序集合)

Redis zset 和 set 一样也是string类型元素的集合，且不允许重复的成员。不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。zset的成员是唯一的，但分数(score)却可以重复。

zset为有序（有限score排序，score相同则元素字典排序）、自动去重的集合数据类型，其底层实现为 字典（dict） + 跳表（skiplist），当数据比较少的时候用 ziplist 编码结构存储。

• ziplist ：如果有序集合保存的所有元素的长度小于默认值64字节且有序集合保存的元素数量小于默认值128个，则采用这种数据结构

• 字典（dict） + 跳表（skiplist）：其他情况采用这种数据结构

1.5.1 字典（dict） + 跳表（skiplist）数据结构

  zset 中最后一个 value 被移除后，数据结构自动删除，内存被回收。 zset 可以用来存粉丝列表，value 值是粉丝的用户 ID，score 是关注时间。我们可以对粉丝列表按关注时间进行排序。

  zset 还可以用来存储学生的成绩，value 值是学生的 ID，score 是他的考试成绩。我们可以对成绩按分数进行排序就可以得到他的名次。

1.5.2 基本操作命令

> zadd books 9.0 "think in java"
(integer) 1

> zadd books 8.9 "java concurrency"
(integer) 1

> zadd books 8.6 "java cookbook"
(integer) 1

> zrange books 0 -1 # 按 score 排序列出，参数区间为排名范围
1) "java cookbook"
2) "java concurrency"
3) "think in java"

> zrevrange books 0 -1 # 按 score 逆序列出，参数区间为排名范围
1) "think in java"
2) "java concurrency"
3) "java cookbook"

> zcard books   # 相当于 count()
(integer) 3

> zscore books "java concurrency" # 获取指定 value 的 score
"8.9000000000000004" # 内部 score 使用 double 类型进行存储，所以存在小数点精度问题

> zrank books "java concurrency" # 排名
(integer) 1

> zrangebyscore books 0 8.91 # 根据分值区间遍历 zset
1) "java cookbook"
2) "java concurrency"

> zrangebyscore books -inf 8.91 withscores # 根据分值区间 (-∞, 8.91] 遍历 zset，同时返回分值。inf 代表 infinite，无穷大的意思。
1) "java cookbook"
2) "8.5999999999999996"
3) "java concurrency"
4) "8.9000000000000004"

> zrem books "java concurrency" # 删除 value
(integer) 1

> zrange books 0 -1
1) "java cookbook"
2) "think in java"

参考链接

Redis 数据类型

Redis 详解

Redis概述

Redis中文官网

Redis

《云原生进阶之容器》专题索引：

1. 第一章Docker核心技术1.1节——Docker综述

1. 第一章Docker核心技术1.2节——Linux容器LXC

1. 第一章Docker核心技术1.3节——命名空间Namespace

1. 第一章Docker核心技术1.4节——chroot技术

1. 第一章Docker核心技术1.5.1节——cgroup综述

1. 第一章Docker核心技术1.5.2节——cgroups原理剖析

1. 第一章Docker核心技术1.5.3节——cgroups数据结构剖析

1. 第一章Docker核心技术1.5.4节——cgroups使用

1. 第一章Docker核心技术1.6节——UnionFS

1. 第一章Docker核心技术1.7节——Docker镜像技术剖析

1. 第一章Docker核心技术1.8节——DockerFile解析

1. 第一章Docker核心技术1.9节——docker-compose容器编排

1. 第一章Docker核心技术1.10节——Docker网络模型设计

1. 第二章——Kubernetes概述

1. 第二章Controller Manager原理剖析--2.1节Controller Manager综述

1. 第二章Controller Manager原理2.2节--client-go剖析

1. 第二章Controller Manager原理2.3节--Reflector分析

1. 第二章Controller Manager原理2.4节--Informer机制剖析

1. 第二章Controller Manager原理2.5节--DeltaFIFO剖析

1. 第二章Controller Manager原理2.6节--Informer controller

1. 第二章Controller Manager原理2.7节--Indexer剖析

1. 第二章Controller Manager原理2.8节--Resync机制

1. 第三章List-Watch机制3.1节-- List-Watch机制剖析

1. 第四章Operator原理4.1节--定制资源（Custom Resource）

1. 第四章Operator原理4.2节--CRD

1. 第四章Operator原理4.3节--Operator模式

1. 第四章Operator原理4.4节--Operator深入实践

1. 第五章容器运行时5.1节--容器运行时总述

1. 第五章容器运行时5.2节--容器运行时接口规范CRI

1. 第五章容器运行时5.3.1--runC简介与使用

1. 第五章容器运行时5.3.2--runC原理解读

1. 第五章容器运行时5.4--容器运行时之Firecracker

1. 第五章容器运行时5.5--容器运行时之Kata Container

1. 第五章容器运行时5.6--容器运行时之gVisor

1. 第六章容器网络6.1--Docker网络模型

1. 第六章容器网络6.2--K8S网络模型

1. 第六章容器网络6.3--CNI及各CNI网络解决方案简述

1. 第六章容器网络6.4.1--Flannel组网方案综述

1. 第六章容器网络6.4.2--Flannel的安装与部署

1. 第六章容器网络6.4.3--Flannel网络模式

1. 第六章容器网络6.5.1--Calico网络方案综述

1. 第六章容器网络6.5.2--Calico网络架构详述

1. 第六章容器网络6.5.3--Calico安装与部署

1. 第六章容器网络6.6.1--Cilium网络方案概述

1. 第六章容器网络6.6.2--Cilium部署

1. 第六章容器网络6.7.1--阿里云Terway网络模式综述