Redis中的hashtable底层数据结构_redis hashtable底层数据结构-优快云博客

制图工具：GitHub网站（如果觉得我的图还行，直接用我的也可以）

Redis整体结构（Redis server v=4.0.12 ，Redis服务器版本为4.0.12）

源码： server.h

typedef struct redisDb {
    dict *dict;                 /* The keyspace for this DB */
    dict *expires;              /* Timeout of keys with a timeout set */
    dict *blocking_keys;        /* Keys with clients waiting for data (BLPOP)*/
    dict *ready_keys;           /* Blocked keys that received a PUSH */
    dict *watched_keys;         /* WATCHED keys for MULTI/EXEC CAS */
    int id;                     /* Database ID */
    long long avg_ttl;          /* Average TTL, just for stats */
} redisDb;

*dict：字典结构

*expire: 过期时间设置

*blocking_keys：阻塞命令

*ready_keys：

*watched_keys

id：数据库编号

avg_ttl：平均ttl

字典结构：dict.h

typedef struct dict {
    dictType *type;
    void *privdata;
    dictht ht[2];
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
    unsigned long iterators; /* number of iterators currently running */
} dict;

*type :

* privdata：私有数据

dictht ht[2] : hashtable，为什么数组长度为2：另一个使用来进行hashtable扩容的

rehashidx：重哈希

iterators：

typedef struct dictType {
    uint64_t (*hashFunction)(const void *key);
    void *(*keyDup)(void *privdata, const void *key);
    void *(*valDup)(void *privdata, const void *obj);
    int (*keyCompare)(void *privdata, const void *key1, const void *key2);
    void (*keyDestructor)(void *privdata, void *key);
    void (*valDestructor)(void *privdata, void *obj);
} dictType;

typedef struct dictht {
    dictEntry **table;
    unsigned long size;
    unsigned long sizemask;
    unsigned long used;
} dictht;

typedef struct dictEntry {
    void *key;
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;
    struct dictEntry *next;
} dictEntry;

key : redisObject

typedef struct redisObject {
    unsigned type:4;
    unsigned encoding:4;
    unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or
                            * LFU data (least significant 8 bits frequency
                            * and most significant 16 bits access time). */
    int refcount;
    void *ptr;
} robj;

type : 区分类型，string，list，hash，set， sorted set

encoding：数据编码，包括embstr， int， raw

Lru：内存淘汰

refcount：内存管理的

*ptr ：真实数据存储

总体示意图：

Ziplist（压缩列表）

示意图：

属性介绍：

zlbytes: 32bit,表示ziplist占用字节的总数
zltail： 32bit,表示ziplist表中最后一项（entry）在ziplist中的偏移字节数，通过zltail可以很方便地找到最后一项，从而可以在 ziplist尾端快速地执行push或pop操作
zlen： 16bit,表示ziplist中数据项（entry）的个数
prerawlen：前一个entry的数据长度
len： entry中的数据长度
data：真实数据的存储

特点：

ziplist是为节省内存空间而生的【紧凑型】。
ziplist是一个为Redis专门提供的底层数据结构之一，本身可以有序也可以无序。当作为list和hash的底层实现时，节点之间没有顺序；当作为zset的底层实现时，节点之间会按照大小顺序排列。

quicklist（快速列表）

源码: quicklist.h

typedef struct quicklist {
    quicklistNode *head;
    quicklistNode *tail;
    unsigned long count;        /* total count of all entries in all ziplists */
    unsigned long len;          /* number of quicklistNodes */
    int fill : 16;              /* fill factor for individual nodes */
    unsigned int compress : 16; /* depth of end nodes not to compress;0=off */
} quicklist;

typedef struct quicklistNode {
    struct quicklistNode *prev;
    struct quicklistNode *next;
    unsigned char *zl;
    unsigned int sz;             /* ziplist size in bytes */
    unsigned int count : 16;     /* count of items in ziplist */
    unsigned int encoding : 2;   /* RAW==1 or LZF==2 */
    unsigned int container : 2;  /* NONE==1 or ZIPLIST==2 */
    unsigned int recompress : 1; /* was this node previous compressed? */
    unsigned int attempted_compress : 1; /* node can't compress; too small */
    unsigned int extra : 10; /* more bits to steal for future usage */
} quicklistNode;

示意图：