官网地址:https://redis.io
一、Redis是做什么用的?
Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache, and message broker.
1、Redis概述
Redis是一个开源的,基于内存的数据结构存储,可用作于数据库、缓存、消息中间件。
(另一种解释:Redis是一个开源的、使用C语言编写的、支持网络交互的、可基于内存也可持久化的Key-Value数据库)
从上述定义我们可以看出,Redis是基于内存进行设计的一种存储数据的载体。首先我们可以看到基于内存,那么相对于磁盘来说,他的特点肯定就是快。再者就是存储,那么我们就会联想到database数据库,可以进行数据的存储。
2、Redis特性
Redis provides data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs, geospatial indexes, and streams. Redis has built-in replication, Lua scripting, LRU eviction, transactions, and different levels of on-disk persistence, and provides high availability via Redis Sentinel and automatic partitioning with Redis Cluster.
Redis支持多种数据结构,包括字符串、哈希表、链表、集合、带范围查询的有序集合、位图、超级日志、地理空间索引和流等。
Redis具备LRU淘汰、事务实现、以及不同级别的硬盘持久化等能力,并且支持副本集和通过Redis Sentinel实现的高可用方案,同时还支持通过Redis Cluster实现的数据自动分片能力。
3、Redis线程模型
You can run atomic operations on these types, like appending to a string; incrementing the value in a hash; pushing an element to a list; computing set intersection, union and difference; or getting the member with highest ranking in a sorted set.
Redis的主要功能都基于单线程模型实现,也就是说Redis使用一个线程来服务所有的客户端请求,同时Redis采用了非阻塞式IO,并精细地优化各种命令的算法时间复杂度,这些信息意味着:
-
Redis是线程安全的(因为只有一个线程),其所有操作都是原子的,不会因并发产生数据异常(Redis6.0之后的多线程主要体现在网络/IO层面,Redis处理命令还是单线程)
-
Redis的速度非常快(因为使用非阻塞式IO,且大部分命令的算法时间复杂度都是O(1))
-
使用高耗时的Redis命令是很危险的,会占用唯一的一个线程的大量处理时间,导致所有的请求都被拖慢。(例如时间复杂度为O(N)的KEYS命令,严格禁止在生产环境中使用)
todo
线程模型深入
二、Redis的基本数据结构及常用命令
本节中将介绍Redis支持的主要数据结构(String、List、Hash、Set、Sorted Set、Bitmap、HyperLogLog),以及相关的常用Redis命令。
首先还是得声明一下,Redis的存储是以key-value的形式的。Redis中的key一定是字符串,value可以是string、list、hash、set、sortset这几种常用的。
Redis并没有直接使用这些数据结构来实现key-value数据库,而是基于这些数据结构创建了一个对象系统。
/**
* Redis使用对象来表示数据库中的键和值。每次我们在Redis数据库中新创建一个键值对时,至少会创建出两个对象。一个是键对象,一个是值对象。
*/
Redis中的每个对象都由一个redisObject结构来表示:
typedef struct redisObject{
// 对象的类型
unsigned type 4:;
// 对象的编码格式
unsigned encoding:4;
// 指向底层实现数据结构的指针
void * ptr;
}robj;
简单来说就是Redis对key-value封装成对象,key是一个对象,value也是一个对象。每个对象都有type(类型)、encoding(编码)、ptr(指向底层数据结构的指针)来表示。
本节只对Redis命令进行扼要的介绍,且只列出了较常用的命令。如果想要了解完整的Redis命令集,或了解某个命令的详细使用方法,请参考官方文档:https://redis.io/commands
1、Redis Key
Redis采用Key-Value型的基本数据结构,任何二进制序列都可以作为Redis的Key使用(例如普通的字符串或一张JPEG图片)
Redis Key的底层源码实现:
Redis Key设计原则:
-
不要使用过长的Key。例如使用一个1024字节的key就不是一个好主意,不仅会消耗更多的内存,还会导致查找的效率降低
-
Key短到缺失了可读性也是不好的,例如"u1000flw"比起"user:1000:followers"来说,节省了寥寥的存储空间,却引发了可读性和可维护性上的麻烦
-
最好使用统一的规范来设计Key,比如"object-type:id:attr",以这一规范设计出的Key可能是"user:1000"或"comment:1234:reply-to"
-
Redis允许的最大Key长度是512MB(对Value的长度限制也是512MB)
2、String(SDS)
SDS:简单动态字符串(Simple dynamic string),柔性数组成员(flexible array member)
Redis中的字符串跟C语言中的字符串,是有点差距的。
Redis中的字符串分两类:二进制安全的和非二进制安全的,对于存储的值是二进制安全的,对于键是非二进制安全的。
Redis使用sdshdr结构来表示一个SDS值:
// sds 类型
typedef char *sds;
// sdshdr 结构
struct sdshdr{
// 字节数组,用于保存字符串
char buf[];
// 记录buf数组中已使用的字节数量,也是字符串的长度
int len;
// 记录buf数组未使用的字节数量
int free;
}
因为自定义类型加入了长度,每次获取字符串长度的时间复杂度就是O(1),而利用len和free属性对追加字符串进行优化,也可以降低重新分配内存的次数。但是这里也有要求就是len和free的更新要小心,不然很容易产生bug。
例子:
2.1 使用SDS的好处
- sdshdr数据结构中用len属性记录了字符串的长度。那么获取字符串的长度时,时间复杂度只需要O(1)。
- SDS不会发生溢出的问题,如果修改SDS时,空间不足。先会扩展空间,再进行修改!(内部实现了动态扩展机制)。
- SDS可以减少内存分配的次数(空间预分配机制)。在扩展空间时,除了分配修改时所必要的空间,还会分配额外的空闲空间(free 属性)。
- SDS是二进制安全的,所有SDS API都会以处理二进制的方式来处理SDS存放在buf数组里的数据。
为什么sds是二进制安全的呢?
我们都知道redis底层是使用C语言写的,C语言是没有字符串类型的,因而,它把字符串存储到char数组之中。但是,C语言读取字符串时,一旦遇到 \0,便终止读取字符串,如下代码:
#include <stdio.h>
int main () {
printf("hello word \0 hello word \0 hello word ");
return 0;
}
输出结果是:
如果存储图片的二进制,肯定会有结束符 \0,此时,图片就不完整,因而,会出现编码的问题。
此外,C语言每次读取字符串,都要重新分配内存空间,这就在分配和回收上浪费了性能。
因而,这就让Redis开发者,不得不重新定义新的数据类型,动态扩展字符串,因而出现了sds的数据类型,全程 simple dynamic string,简单动态字符串。
2.2 SDS扩容原理
那么sdsMakeRoomFor是怎么实现扩容的呢,具体扩容方案是什么呢?下面就是redis的源码:
/*
* 对 sds 的 buf 进行扩展,扩展的长度不少于 addlen 。
*
* T = O(N)
*/
sds sdsMakeRoomFor(
sds s,
size_t addlen // 需要增加的空间长度
)
{
struct sdshdr *sh, *newsh;
size_t free = sdsavail(s);
size_t len, newlen;
// 剩余空间可以满足需求,无须扩展
if (free >= addlen) return s;
sh = (void*) (s-(sizeof(struct sdshdr)));
// 目前 buf 长度
len = sdslen(s);
// 新 buf 长度
newlen = (len+addlen);
// 如果新 buf 长度小于 SDS_MAX_PREALLOC 长度
// 那么将 buf 的长度设为新 buf 长度的两倍
if (newlen < SDS_MAX_PREALLOC)
newlen *= 2;
else
newlen += SDS_MAX_PREALLOC;
// 扩展长度
newsh = zrealloc(sh, sizeof(struct sdshdr)+newlen+1);
if (newsh == NULL) return NULL;
newsh->free = newlen - len;
return newsh->buf;
}
可以看到,如果新字符串长度比SDS_MAX_PREALLOC小,则将其长度double,如果大于SDS_MAX_PREALLOC则再给SDS_MAX_PREALLOC空间。这个值redis定义的是1024*1024,即1MB。
这样一来,扩容一次多给一倍请求的空间,可以减少分配内存的次数,当然稍微有点浪费,但append操作一般情况不会太多,如果场景append很多还要优化redis的代码。
小结:
- Redis的字符串表示为sds,不是char*;
- 对比原生char*,sds有以下优势:
- 长度计算只需O(1)时间复杂度;
- 字符串追加更高效;
- 二进制安全;
- sds对追加操作有优化,加快追加速度,降低内存重新分配次数,代价是浪费一些内存,并且不会主动释放。
3、List (链表)
Redis列表是简单的字符串列表,按照插入顺序排序。你可以添加一个元素导列表的头部(左边)或者尾部(右边)
一个列表最多可以包含 232 - 1 个元素 (4294967295, 每个列表超过40亿个元素)。
Redis中链表的具体跟Java中的LinkedList链表有相似之处。Redis链表的底层实现原理:
使用listNode结构来表示每个节点:
typedef strcut listNode{
//前置节点
strcut listNode *pre;
//后置节点
strcut listNode *pre;
//节点的值
void *value;
}listNode
使用listNode是可以组成链表了,Redis中使用list结构来持有链表:
typedef struct list{
//表头结点
listNode *head;
//表尾节点
listNode *tail;
//链表长度
unsigned long len;
//节点值复制函数
void *(*dup) (viod *ptr);
//节点值释放函数
void (*free) (viod *ptr);
//节点值对比函数
int (*match) (void *ptr,void *key);
}list
3.1 Redis链表实现
- 每个链表节点由一个
listNode
结构来表示, 每个节点都有一个指向前置节点和后置节点的指针, 所以 Redis 的链表实现是双端链表。 - 每个链表使用一个
list
结构来表示, 这个结构带有表头节点指针、表尾节点指针、以及链表长度等信息。 - 因为链表表头节点的前置节点和表尾节点的后置节点都指向
NULL
, 所以 Redis 的链表实现是无环链表。 - 通过为链表设置不同的类型特定函数, Redis 的链表可以用于保存各种不同类型的值。
3.2 Redis链表中的三个函数
-
dup函数用于复制链表节点所保存的值
-
free函数用于释放链表节点所保存的值
match
函数则用于对比链表节点所保存的值和另一个输入值是否相等
3.3 Redis链表的特性
- 无环双向链表
- 获取表头指针,表尾指针,链表节点长度的时间复杂度均为O(1)
- 链表使用
void *
指针来保存节点值,可以保存各种不同类型的值,体现了多态思想
3.4 Redis链表的应用场景
Redis链表被广泛用于列表键、发布与订阅、慢查询、监视器等。
4、Hash表
Redis hash 是一个string类型的field和value的映射表,hash特别适合用于存储对象。
Redis 中每个 hash 可以存储 232 - 1 键值对(40多亿)。
在Redis中,key-value
的数据结构底层就是哈希表来实现的。对于哈希表来说,我们也并不陌生。在Java中,哈希表实际上就是数组+链表的形式来构建的。下面我们来看看Redis的哈希表是怎么构建的吧。
4.1 hash的底层实现
在Redis里边,哈希表使用dictht结构来定义:
typedef struct dictht{
//哈希表数组
dictEntry **table;
//哈希表大小
unsigned long size;
//哈希表大小掩码,用于计算索引值
//总是等于size-1
unsigned long sizemark;
//哈希表已有节点数量
unsigned long used;
}dictht
我们下面继续写看看哈希表的节点是怎么实现的吧:
typedef struct dictEntry {
//键
void *key;
//值
union {
void *value;
uint64_tu64;
int64_ts64;
}v;
//指向下个哈希节点,组成链表
struct dictEntry *next;
}dictEntry;
从结构上看,我们可以发现:Redis实现的哈希表和Java中实现的是类似的。只不过Redis多了几个属性来记录常用的值:sizemark(掩码)、used(已有的节点数量)、size(大小)。
同样地,Redis为了更好的操作,对哈希表往上再封装了一层(参考上面的Redis实现链表),使用dict结构来表示:
typedef struct dict {
//类型特定函数
dictType *type;
//私有数据
void *privdata;
//哈希表
dictht ht[2];
//rehash索引
//当rehash不进行时,值为-1
int rehashidx;
}dict;
//-----------------------------------
typedef struct dictType{
//计算哈希值的函数
unsigned int (*hashFunction)(const void * key);
//复制键的函数
void *(*keyDup)(void *private, const void *key);
//复制值得函数
void *(*valDup)(void *private, const void *obj);
//对比键的函数
int (*keyCompare)(void *privdata , const void *key1, const void *key2)
//销毁键的函数
void (*keyDestructor)(void *private, void *key);
//销毁值的函数
void (*valDestructor)(void *private, void *obj);
}dictType
从代码实现和示例图上我们可以发现,Redis中有两个哈希表:
- ht[0]:用于存放真实的
key-vlaue
数据 - ht[1]:用于扩容(rehash)
Redis中哈希算法和哈希冲突跟Java实现的差不多,它俩差异就是:
- Redis哈希冲突时:是将新节点添加在链表的表头。
- JDK1.8后,Java在哈希冲突时:是将新的节点添加到链表的表尾。
4.2 rehash的过程
下面来具体讲讲Redis是怎么rehash的,因为我们从上面可以明显地看到,Redis是专门使用一个哈希表来做rehash的。这跟Java中的HashMap一次性直接rehash是有区别的,跟ConcurrentHashMap的rehash过程是一致的。
在对哈希表进行扩展或者收缩操作时,reash过程并不是一次性地完成的,而是 渐进式地完成的。
Redis在rehash时采取渐进式的原因:数据量如果过大的话,一次性rehash会有庞大的计算量,这很可能导致服务器一段时间内停止服务。
Redis具体的rehash过程:
- 在字典中维持一个索引计数器变量rehashidx,并设置为0,表示rehash开始。
- 在rehash期间每次对字典进行增加、查询、删除和更新操作时,除了执行指定命令外;还会将ht[0]中rehashidx索引上的值rehash到ht[1],操作完成后rehashidx+1。
- 字典操作不断执行,最终在某个时间点,所有的键值对完成rehash,这时将rehashidx设置为-1,表示rehash完成。
- 在渐进式rehash过程中,字典会同时使用两个哈希表ht[0]和ht[1],所有的更新、删除、查找操作也会在两个哈希表进行。例如要查找一个键的话,服务器会优先查找ht[0],如果不存在,再查找ht[1],诸如此类。此外当执行新增操作时,新的键值对一律保存到ht[1],不再对ht[0]进行任何操作,以保证ht[0]的键值对数量只减不增,直至变为空表。(可以理解为多个工人一起搬运的过程)
5、Set
Redis的Set是string类型的无序集合。集合成员是唯一的,这就意味着集合中不能出现重复的数据。
Redis 中 集合是通过哈希表实现的,所以添加,删除,查找的复杂度都是O(1)。
集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。
Redis的集合对象set的底层存储结构使用了intset和hashtable两种数据结构存储的,intset我们可以理解为数组,hashtable就是普通的哈希表(key为set的值,value为null)。
Set的底层存储intset和hashtable是存在编码转换的,使用intset存储必须满足下面两个条件,否则使用hashtable,条件如下:
- 结合对象保存的所有元素都是整数值
- 集合对象保存的元素数量不超过512个
5.1 intset的数据结构
intset内部其实是一个数组(int8_t coentents[]数组),而且存储数据的时候是有序的,因为在查找数据的时候是通过二分查找来实现的。
typedef struct intset {
// 编码方式
uint32_t encoding;
// 集合包含的元素数量
uint32_t length;
// 保存元素的数组
int8_t contents[];
} intset;
intset存储结构
5.2 HashTable的数据结构
5.3 Redis Set 存储过程
以set的sadd命令为例子,整个添加过程如下:
- 检查set是否存在不存在则创建一个set结合。
- 根据传入的set集合一个个进行添加,添加的时候需要进行内存压缩。
- setTypeAdd执行set添加过程中会判断是否进行编码转换。
void saddCommand(redisClient *c) {
robj *set;
int j, added = 0;
// 取出集合对象
set = lookupKeyWrite(c->db,c->argv[1]);
// 对象不存在,创建一个新的,并将它关联到数据库
if (set == NULL) {
set = setTypeCreate(c->argv[2]);
dbAdd(c->db,c->argv[1],set);
// 对象存在,检查类型
} else {
if (set->type != REDIS_SET) {
addReply(c,shared.wrongtypeerr);
return;
}
}
// 将所有输入元素添加到集合中
for (j = 2; j < c->argc; j++) {
c->argv[j] = tryObjectEncoding(c->argv[j]);
// 只有元素未存在于集合时,才算一次成功添加
if (setTypeAdd(set,c->argv[j])) added++;
}
// 如果有至少一个元素被成功添加,那么执行以下程序
if (added) {
// 发送键修改信号
signalModifiedKey(c->db,c->argv[1]);
// 发送事件通知
notifyKeyspaceEvent(REDIS_NOTIFY_SET,"sadd",c->argv[1],c->db->id);
}
// 将数据库设为脏
server.dirty += added;
// 返回添加元素的数量
addReplyLongLong(c,added);
}
稍微深入分析一下set的单个元素的添加过程,首先如果已经是hashtable的编码,那么我们就走正常的hashtable的元素添加,如果原来是intset的情况,那么我们就需要进行如下判断:
- 如果能够转成int的对象(isObjectRepresentableAsLongLong),那么就用intset保存。
- 如果用intset保存的时候,如果长度超过512(REDIS_SET_MAX_INTSET_ENTRIES)就转为hashtable编码。
- 其他情况统一用hashtable进行存储。
/*
* 多态 add 操作
*
* 添加成功返回 1 ,如果元素已经存在,返回 0 。
*/
int setTypeAdd(robj *subject, robj *value) {
long long llval;
// 字典
if (subject->encoding == REDIS_ENCODING_HT) {
// 将 value 作为键, NULL 作为值,将元素添加到字典中
if (dictAdd(subject->ptr,value,NULL) == DICT_OK) {
incrRefCount(value);
return 1;
}
// intset
} else if (subject->encoding == REDIS_ENCODING_INTSET) {
// 如果对象的值可以编码为整数的话,那么将对象的值添加到 intset 中
if (isObjectRepresentableAsLongLong(value,&llval) == REDIS_OK) {
uint8_t success = 0;
subject->ptr = intsetAdd(subject->ptr,llval,&success);
if (success) {
// 添加成功
// 检查集合在添加新元素之后是否需要转换为字典
// #define REDIS_SET_MAX_INTSET_ENTRIES 512
if (intsetLen(subject->ptr) > server.set_max_intset_entries)
setTypeConvert(subject,REDIS_ENCODING_HT);
return 1;
}
// 如果对象的值不能编码为整数,那么将集合从 intset 编码转换为 HT 编码
// 然后再执行添加操作
} else {
setTypeConvert(subject,REDIS_ENCODING_HT);
redisAssertWithInfo(NULL,value,dictAdd(subject->ptr,value,NULL) == DICT_OK);
incrRefCount(value);
return 1;
}
// 未知编码
} else {
redisPanic("Unknown set encoding");
}
// 添加失败,元素已经存在
return 0;
}
6、Sorted Set
Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。
不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
有序集合的成员是唯一的,但分数(score)却可以重复。
集合是通过哈希表实现的,所以添加,删除,查找的复杂度都是O(1)。 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。
以下表格是五种数据类型对应的11种编码格式: