Redis学习日志（一）

底层数据结构：sds、list、dict、ziplist、intset、skiplist

1.String

Redis构建了简单动态字符串SDS来作为默认字符串表示，属于可修改字符串的值。
当一些如打印日志等不需被修改的字符串则用C语言传统字符串表示。
sds用于存储字符串、AOF缓冲区、客户端状态中的输入缓冲区等。
sds实际是char型指针，即C语言的字符串表述形式
sdshdr是redis中的简单动态字符串结构，而实际上在使用字符串时，
依旧是使用char* 而不是sdshdr，在C中可根据地址偏移，
得到该char* （sds）所在的sdshdr的地址，借用指针进行操作。

sds定义：
        struct sdshdr{
            int len;//记录buf数组中已使用字节长度，等于SDS保存的字符串长度
            int free;//记录buf数组中未使用的字节长度
            char buf[];//字符数组，用于保存字符串
        }

buf[]保存字符，最后一个字节保存空字符’\0’结尾，这1字节空间不计算在len属性中。
遵循空字符结尾惯例，可对C字符串函数库中进行一些重用。

        /* 根据给定的初始化字符串 init 和字符串长度 initlen
         * 创建一个新的 sds
         * 参数
         *  init ：初始化字符串指针
         *  initlen ：初始化字符串的长度
         * 返回值
         *  sds ：创建成功返回 sdshdr 相对应的 sds
         *        创建失败返回 NULL
         * 复杂度
         *  T = O(N) */
        sds sdsnewlen(const void *init, size_t initlen) {
            struct sdshdr *sh;
            // 根据是否有初始化内容，选择适当的内存分配方式
            // T = O(N)
            if (init) {
                // zmalloc 不初始化所分配的内存
                sh = zmalloc(sizeof(struct sdshdr)+initlen+1);
            } else {
                // zcalloc 将分配的内存全部初始化为 0
                sh = zcalloc(sizeof(struct sdshdr)+initlen+1);
            }
            // 内存分配失败，返回
            if (sh == NULL) return NULL;
            // 设置初始化长度
            sh->len = initlen;
            // 新 sds 不预留任何空间
            sh->free = 0;
            // 如果有指定初始化内容，将它们复制到 sdshdr 的 buf 中
            // T = O(N)
            if (initlen && init)
                memcpy(sh->buf, init, initlen);
            // 以 \0 结尾
            sh->buf[initlen] = '\0';
            // 返回 buf 部分，而不是整个 sdshdr
            return (char*)sh->buf;
        }    

SDS与C字符串相比：
①SDS结构的len属性记录了字符串长度，当要获取时，复杂度仅为O(1)，无需进行O(n)的遍历；
②杜绝缓冲区溢出：在对SDS字符串进行修改时，会检查SDS剩余空间(free属性)是否充足，
若不足则先进行扩展。
③减少修改字符串时的内存重分配次数
④可保存二进制数据
⑤兼容部分C字符串函数

2.链表

Redis链表结构(adlist.h/listNode)

            typedef struct listNode{
                struct listNode *prev;//前置节点
                struct listNode *next;//后置节点
                void *value;//节点值
            }listNode;

对listNode进行一层包装(adlist/list)

            typedef struct list{
                listNode *head//表头节点
                listNode *tail;//表尾结点
                unsigned long len;//链表包含的节点数量
                void *(*dup)(void *ptr);//节点值复制函数
                void (*free)(void *ptr);//节点值释放函数
                int (*match)(void *ptr,void *key);//节点值对比函数
            }list;

|list listNode <– listNode <–listNode
|head –> value=.. –> value=..–> value=.. –>null
|tail —————————————↑
|len=3
|dup –>…..list结构中的3个listNode
|free –>….
|match –>…
Redis链表特性：
双端：链表节点有prev和next指针
无环：表头节点的prev和表尾节点的next指向null 不循环
带头指针和尾指针：list结构的head指针和tail指针
计数器:list结构的len属性保存节点个数
多态：链表节点使用void*指针保存节点值，
可通过list结构的dup、free、match属性为节点值设置类型特定函数
因此链表可保存各种不同类型的值。
（①void指针可以指向任意类型的数据，亦即可用任意数据类型的指针对void指针赋值
②可以用void指针来作为函数形参，就可以接受任意数据类型的指针作为参数）

3.字典

(map映射，用于保存键值对 key-value)
Redis哈希表结构(dict.h/dictht)

            typedef struct dictht{
                dictEntry **table;//哈希表数组
                unsigned long size;//哈希表大小
                unsigned long sizemask;//哈希表大小掩码用于计算索引值(=size-1)
                unsigned long used;//已有节点数量
            }dictht;

table数组中每个元素指向dict.h/dictEntry结构的指针。
每个dictEntry结构保存一个键值对。size属性记录哈希表大小(table数组大小)
哈希表节点dictEntry

            typedef struct dictEntry{
                void *key;//键
                union{ //值
                    void *val;
                    uint64_tu64;
                    int64_ts64;
                }v;
                struct dictEntry *next;//下个哈希表节点
            }dictEntry;

key属性保存键值对中的键，v属性保存值，值可以是一个指针、uint64_t整数或int64_t整数。
next属性指向另一个哈希表节点指针，可以将多个哈希值相同的键值对连接起来，解决键冲突问题。
例：

|dictht   两个索引值相同的键k1 k0 通过dictEntry结构的next指针连接起来
|table  ---->   dictEntry*[4]
|size=4         |0 -->null
|sizemask=3     |1 -->null
|used=2         |2 -->null
                |3 --> dictEntry  --> dictEntry -->null
                       |k1 |v1        |k0 |v0

dict.h/dict结构表示字典(在dictht上再包装一层)

            typedef struct dict{
                dictType *type;//类型特定函数
                void *privdata;//私有数据
                dictht ht[2];//哈希表
                int trehashidx;//rehash索引，当rehash不在进行时，为-1
            }dict;

type属性和privdata属性针对不同类型的键值对，
type指向dictType结构指针，每个dictType结构保存了一簇特定类型键值对的操作函数
privdata属性保存了需要传给特定函数的可选参数
typedef struct dictType{
unsigned int (*hashFunction)(const void *key);
void *(*keyDup) (void *privdata,const void *key);
void *(*valDup) (void *privdata,const void *key);
int (*keyCompare)(void *privdata,const void *key1,const void *key2);
void *(*keyDestructor) (void *privdata, void *key);
void *(*valDestructor) (void *privdata,void *obj);
}dictType;
ht属性是包含两个项(dictht)的数组，一般只使用ht[0]哈希表,当对ht[0]进行rehash时才使用ht[1]
rehashidx属性记录rehash,若当前没有在进行，则值为-1。
例：普通状态下（没有rehash）的字典 （图4-3普通状态下的字典）

4.哈希算法

当将一个新键值对加入到字典中时，先计算键的哈希值和索引值(哈希值对sizemask取模)，
再根据索引值将新键值节点放入到dictht的table数组中合适的dictEntry链表中。
hash=dict->type->hashFunction(key);
index=hash& dict->ht[x].sizemask;
例：添加一个新键值对的过程图（图4-5添加新键值对）

键冲突问题:有两个或以上数量的键分配到同一个索引上时
开放地址法(再散列，直到索引不冲突)：反复计算索引，并要求有足够的索引能用来存储。
链地址法：当索引冲突时，在该索引下以链表的方式存储
Redis中dictEntry节点组成的链表没有指向尾部的指针，因此采用头插法，将新节点添加到链表表头O(1)

5.rehash

当哈希表保存的键值对逐渐增多或减少时，为了维持合理的负载因子，对哈希表大小进行相应的扩展或收缩
步骤如下：
1)为字典ht[1]哈希表分配空间，
若是扩展操作，则ht[1]的大小为第一个大于等于ht[0].used*2 的2^n (即size=2^n>=ht[0].used*2)
若是收缩操作，则ht[1]的大小为第一个大于等于ht[0].used的2^n (即size=2^n>=ht[0].used)
2)将保存在ht[0]中的所有键值对重新计算散列到ht[1]中
3)完成上述rehash操作后，释放ht[0],更换ht[1]为ht[0],创建一个新的空ht[1]为下次rehash使用
(即 free(ht[0]),*ht[0]=*ht[1],ht[1]=new dictht)
过程图（图4-8rehash扩展）

        int dictRehash(dict *d, int n) {
            // 只可以在 rehash 进行中时执行
            if (!dictIsRehashing(d)) return 0;
            // 进行 N 步迁移
            // T = O(N)
            while(n--) {
                dictEntry *de, *nextde;
                /* Check if we already rehashed the whole table... */
                // 如果 0 号哈希表为空，那么表示 rehash 执行完毕
                // T = O(1)
                if (d->ht[0].used == 0) {
                    // 释放 0 号哈希表
                    zfree(d->ht[0].table);
                    // 将原来的 1 号哈希表设置为新的 0 号哈希表
                    d->ht[0] = d->ht[1];
                    // 重置旧的 1 号哈希表
                    _dictReset(&d->ht[1]);
                    // 关闭 rehash 标识
                    d->rehashidx = -1;
                    // 返回 0 ，向调用者表示 rehash 已经完成
                    return 0;
                }
                /* Note that rehashidx can't overflow as we are sure there are more
                 * elements because ht[0].used != 0 */
                // 确保 rehashidx 没有越界
                assert(d->ht[0].size > (unsigned)d->rehashidx);
                // 略过数组中为空的索引，找到下一个非空索引
                while(d->ht[0].table[d->rehashidx] == NULL) d->rehashidx++;
                // 指向该索引的链表表头节点
                de = d->ht[0].table[d->rehashidx];
                /* Move all the keys in this bucket from the old to the new hash HT */
                // 将链表中的所有节点迁移到新哈希表
                // T = O(1)
                while(de) {
                    unsigned int h;
                    // 保存下个节点的指针
                    nextde = de->next;
                    /* Get the index in the new hash table */
                    // 计算新哈希表的哈希值，以及节点插入的索引位置
                    h = dictHashKey(d, de->key) & d->ht[1].sizemask;
                    // 插入节点到新哈希表
                    de->next = d->ht[1].table[h];
                    d->ht[1].table[h] = de;
                    // 更新计数器
                    d->ht[0].used--;
                    d->ht[1].used++;
                    // 继续处理下个节点
                    de = nextde;
                }
                // 将刚迁移完的哈希表索引的指针设为空
                d->ht[0].table[d->rehashidx] = NULL;
                // 更新 rehash 索引
                d->rehashidx++;
            }
            return 1;
        }

哈希表扩展与收缩条件：(以下条件满足一个即可)
负载因子=哈希表已保存节点数量/哈希表大小
load_factor=ht[0].used/ht[0].size;
扩展：
1)服务器目前没有在执行BGSAVE/BGREWRITEAOF命令，且哈希表负载因子>=1
2)服务器目前正在执行BGSAVE/BGREWRITEAOF命令，但哈希表负载因子>=5
收缩：
当负载因子<0.1时，执行收缩操作。

6.渐进式rehash

当哈希表中的键值对比较多时，如果采用集中式一次性完成rehash会造成一定的影响
为了避免对服务器性能造成影响，采用多次渐进式地将ht[0]里的键值对rehash到ht[1]
步骤如下：
1)为ht[1]分配空间，让字典同时持有ht[0]、ht[1]
2)维持索引计数器变量rehashidx,设置为0，表示rehash开始。
3)rehash期间，对字典进行正常操作的同时，会顺带将ht[0]上rehashidx索引上的键值对rehash到ht[1],完成后rehashidx+1
4)随着字典操作的不断进行，最终使ht[0]上所有键值对rehash到ht[1]上，修改rehashidx值为-1，过程结束。

// 在给定毫秒数内，以 100 步为单位，对字典进行 rehash 。
                int dictRehashMilliseconds(dict *d, int ms) {
                    // 记录开始时间
                    long long start = timeInMilliseconds();
                    int rehashes = 0;
                    while(dictRehash(d,100)) {
                        rehashes += 100;
                        // 如果时间已过，跳出
                        if (timeInMilliseconds()-start > ms) break;
                    }
                    return rehashes;
                }

注意：rehashidx的值范围为[-1,ht[0].sizemask]
在渐进式rehash期间，对字典的操作会在ht[0]中先查找对应键，没有命中则在ht[1]中查找，
对于新增的键，会一律存在ht[1]中，使ht[0]逐渐变成空表。

7.跳跃表

有序数据结构，在每个节点中维持多个指向其他节点的指针，达到快速访问节点的目的。
有序链表中，节点具有多个指向，可加快搜索，复杂度O(logn)
level 3 -INF———–21↓————————-55↓
level 2 -INF—2↓——-21↓——-37↓————55↓
level 1 -INF–>2–>17–>21–>33–>37–>46–>55
Redis跳跃表由redis.h/zskiplistNode和redis.h/zskiplist结构定义
zskiplistNode表示跳跃表节点， zskiplist表示关于节点的相关信息，如节点数量、头尾指针等
(图5-1跳跃表)

            typedef struct zskiplistNode{
                struct zskiplistLevel{ //层
                    struct zskiplistNode *forward; //前进指针
                    unsigned int span; //跨度
                }level[];

                struct zskiplistNode *backward;//后退指针
                double score;//分值
                robj *obj;//成员对象
            }zskiplistNode;

1)层：跳跃表节点的level数组可包含多个元素，每个元素包含指向其他节点的指针。
level[i].forward代表 本节点在第i层中的指向的下一个节点
每次创建一个新跳跃表节点时，根据幂次定律随机生成一个介于1和32之间的值作为level数组大小，即高度
2)跨度：level[i].span属性，记录两个节点之间的距离。跨度用于计算目标节点在跳跃表中的排位。(将沿途访问过的所有层跨度累加)
3)后退指针：用于从尾部逆向访问至表头，每次仅后退一个节点。
4)分值和成员：跳跃表中节点按分值从小到大排序，obj成员指向一个字符串对象，保存SDS值
(同一个跳跃表中各节点的成员对象是唯一的，但分值可以重复)
使用zskiplist结构维持跳跃表，快速访问表头、表尾节点，获取节点数量等信息。

typedef struct zskiplist{
struct zskiplistNode *header,*tail;//表头尾节点
unsigned long length;//表中节点数量
int level;//表中最高层数
}zskiplist;
/* 创建一个层数为 level 的跳跃表节点，
* 并将节点的成员对象设置为 obj ，分值设置为 score 。
* 返回值为新创建的跳跃表节点  */
zskiplistNode *zslCreateNode(int level, double score, robj *obj) {
// 分配空间
zskiplistNode *zn = zmalloc(sizeof(*zn)+level*sizeof(struct zskiplistLevel));
// 设置属性
zn->score = score;
zn->obj = obj;
return zn;
}
/* 创建并返回一个新的跳跃表,ZSKIPLIST_MAXLEVEL=32  */
zskiplist *zslCreate(void) {
int j;
zskiplist *zsl;
// 分配空间
zsl = zmalloc(sizeof(*zsl));
// 设置高度和起始层数
zsl->level = 1;
zsl->length = 0;
// 初始化表头节点
// T = O(1)
zsl->header = zslCreateNode(ZSKIPLIST_MAXLEVEL,0,NULL);
for (j = 0; j < ZSKIPLIST_MAXLEVEL; j++) {
zsl->header->level[j].forward = NULL;
zsl->header->level[j].span = 0;
}
zsl->header->backward = NULL;
// 设置表尾
zsl->tail = NULL;
return zsl;
}
/**由于跳跃表的第一层level[0]是简单顺序链表形式保存所有节点关系的。
因此在需要释放表时遍历level[0]依次释放即可。*/
void zslFree(zskiplist *zsl) {
zskiplistNode *node = zsl->header->level[0].forward, *next;
// 释放表头
zfree(zsl->header);
// 释放表中所有节点
// T = O(N)
while(node) {
next = node->level[0].forward;
zslFreeNode(node);
node = next;
}
// 释放跳跃表结构
zfree(zsl);
}
e.HyperLogLog：hyperloglog.c 中的 hllhdr
struct hllhdr {
char magic[4];      /* "HYLL" */
uint8_t encoding;   /* HLL_DENSE or HLL_SPARSE. */
uint8_t notused[3]; /* Reserved for future use, must be zero. */
uint8_t card[8];    /* Cached cardinality, little endian. */
uint8_t registers[]; /* Data bytes. */
};

7.5 HyperLogLog

可以接受多个元素作为输入，并给出输入元素的基数估算值：
基数：集合中不同元素的数量。比如 {‘apple’, ‘banana’, ‘cherry’, ‘banana’, ‘apple’} 的基数就是 3 。
估算值：算法给出的基数并不是精确的，可能会比实际稍微多一些或者稍微少一些，但会控制在合
理的范围之内。
HyperLogLog 的优点是，即使输入元素的数量或者体积非常非常大，计算基数所需的空间总是固定
的、并且是很小的。
在 Redis 里面，每个 HyperLogLog 键只需要花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基
数。这和计算基数时，元素越多耗费内存就越多的集合形成鲜明对比。
但是，因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以
HyperLogLog 不能像集合那样，返回输入的各个元素。
redis> PFADD str1 “apple” “banana” “cherry”
(integer) 1
redis> PFCOUNT str1
(integer) 3
redis> PFADD str2 “apple” “cherry” “durian” “mongo”
(integer) 1
redis> PFCOUNT str2
(integer) 4
redis> PFMERGE str1&2 str1 str2
OK
redis> PFCOUNT str1&2
(integer) 5

8.整数集合

用于保存整数值的集合抽象数据结构，保存int16_t、int32_t、int64_t，无重复元素。
intset.h/intset结构：

typedef struct intset {
uint32_t encoding;//编码方式
uint32_t length;//元素数量
int8_t contents[];//元素数组
}intset;

contents数组中元素按从小到大排列，不含重复项。
contents元素类型取决于encoding
|intset
|encoding=INT16
|length=5
|contents –> |-5|18|89|252|14632|
sizeof(int16_t)*5=80位空间大小
当新添加的整数类型比原集合编码类型要大时，则对集合进行升级更新，将数组内元素都变为较大的类型并调整内存空间位
如，当原集合类型为INT_16，新增一个INT_64时，则将原元素都更改为INT_64 调整集合空间大小.
升级：更改编码并修改原底层数组中元素值的地址，改为新编码方式赋予
详见 源码intset.c/intsetUpgradeAndAdd 函数
例： 原先contents[0] 为INT_16编码存储的整数5 ，地址范围为 0X….a - 0X….b
当contents编码升级为INT_32时，对于整数5的地址可用空间变大了0X…a -0X…c
所以需要对整数5以INT_32编码形式重新赋予contents[0],覆盖整个可用空间地址。

// 根据集合原来的编码方式，从底层数组中取出集合元素
// 然后再将元素以新编码的方式添加到集合中
// 当完成了这个步骤之后，集合中所有原有的元素就完成了从旧编码到新编码的转换
// 因为新分配的空间都放在数组的后端，所以程序先从后端向前端移动元素
// 举个例子，假设原来有 curenc 编码的三个元素，它们在数组中排列如下：
// | x | y | z | 
// 当程序对数组进行重分配之后，数组就被扩容了（符号 ？ 表示未使用的内存）：
// | x | y | z | ? |   ?   |   ?   |
// 这时程序从数组后端开始，重新插入元素：
// | x | y | z | ? |   z   |   ?   |
// | x | y |   y   |   z   |   ?   |
// |   x   |   y   |   z   |   ?   |
// 最后，程序可以将新元素添加到最后 ？ 号标示的位置中：
// |   x   |   y   |   z   |  new  |
// 上面演示的是新元素比原来的所有元素都大的情况，也即是 prepend == 0
// 当新元素比原来的所有元素都小时（prepend == 1），调整的过程如下：
// | x | y | z | ? |   ?   |   ?   |
// | x | y | z | ? |   ?   |   z   |
// | x | y | z | ? |   y   |   z   |
// | x | y |   x   |   y   |   z   |
// 当添加新值时，原本的 | x | y | 的数据将被新值代替
// |  new  |   x   |   y   |   z   |
while(length--)
_intsetSet(is,length+prepend,_intsetGetEncoded(is,length,curenc));
//_intsetGetEncoded返回以旧编码获得的length位置上的整数值value，
//_intsetSet将value以新编码放到contents数组的正确位置上。

9.压缩列表

ziplist,列表键和哈希键的底层实现之一。
压缩列表采取的方式犹如单向链表，比双端链表要节省空间，
在节点方面，与双端链表相比，数据结构更加简单。
但双端链表结构记录更详细信息，对于复杂情况更加快速。
例：
redis> RPUSH lst 1 3 5 12345 “hello” “good”
(integer)6
redis> OBJECT ENCODING lst
“ziplist”
列表键lst中包含的是较小的整数值及短字符串。
当一个哈希键中只包含少量键值对，且键值是小整数值或短字符串，也会使用压缩列表
例：
redis> HMSET profile “name” “Jack” “age” 28 “job” “Programmer”
OK
redis> OBJECT ENCODING profile
“ziplist”
压缩列表由一系列特殊编码的连续内存块组成，顺序型数据结构。
一个压缩列表可包含任意多个结点entry,每个节点可保存一个字节数组或整数值。
压缩列表组成部分：
|zlbytes|zltail|zllen|entry1|entry2|…|entryN|zlend|
zlbytes: uint32_t 记录整个压缩列表占用的内存字节数
zltail ：uint32_t 记录压缩列表表尾节点距离起始地点的偏移量。
zllen ：uint16_t 记录压缩列表包含的节点数量(数量大于uint16_t_MAX时需要遍历计算)
entryX ： 列表节点
zlend ：uint8_t 标记末端。
压缩列表节点组成部分：
|previous_entry_length|encoding|content|
节点可保存一个字节数组或一个整数值
字节数组：
1)长度小于等于63（2^6 -1）字节的字节数组
2)长度小于等于16383（2^14 -1）字节的字节数组
3)长度小于等于4294967295（2^32 -1）字节的字节数组
整数值：
1)4位长，介于0-12的无符号整数
2)1字节长的有符号整数
3)3字节长的有符号整数
4)int16_t类型整数
5)int32_t类型整数
6)int64_t类型整数
|previous_entry_length|:1或5字节 记录压缩列表中前一个节点的长度
|encoding|:记录节点content属性所保存数据的类型及长度
|content|：保存节点的值，值的类型和长度由encoding属性决定

/* 保存 ziplist 节点信息的结构  */
typedef struct zlentry {
// prevrawlen ：前置节点的长度
// prevrawlensize ：编码 prevrawlen 所需的字节大小 用来计算节点的编码
unsigned int prevrawlensize, prevrawlen;
// lensize ：编码 len 所需的字节大小
unsigned int lensize, len;
// 当前节点 header 的大小
// 等于 prevrawlensize + lensize
unsigned int headersize;
// 当前节点值所使用的编码类型
unsigned char encoding;
// 指向当前节点的指针
unsigned char *p;
} zlentry; // len ：当前节点值的长度

压缩列表小结{
是一种为节约内存开发的顺序型数据结构
用作列表键和哈希键的底层实现之一
可包含多个节点，每个节点保存一个字节数组或整数值
添加新节点或删除节点，可能引发连锁更新操作，不过出现的几率不高
}