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"