Redis数据的底层存储原理

redis底层是用什么结构来存储数据的呢?

我们从源码上去理解就会容易的多:
  redis底层是使用C语言来编写的,我们可以看到它的数据结构声明。一个 dict 有两个dictht,一个dictht有一个dictEntry数组,每个dictEntry有next指针,redisObject是真正存储redis各种类型的结构。因此是一个链表结构。从上面的分析可以看出Redis用拉链法解决冲突的哈希表结构。

“链地址法”的问题在于当碰撞剧烈时,性能退化严重,例如:当有n个数据,m个槽位,如果m=1,则整个Hash表退化为链表,查询复杂度O(n)

为了避免Hash碰撞,Redis的方案是“双dictht”,正常流程使用一个dictht,当发现碰撞剧烈(判断依据为当前槽位数和Key数的对比),分配一个更大的dictht,然后逐步将数据从老的dictht迁移到新的dictht上去。这就需要进行rehash

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;
/* This is our hash table structure. Every dictionary has two of this as we
* implement incremental rehashing, for the old to the new table. */
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;
//redisObject是真正存储redis各种类型的结构,定义如下:
#define REDIS_STRING 0  
#define REDIS_LIST 1  
#define REDIS_SET 2  
#define REDIS_ZSET 3  
#define REDIS_HASH 4  
typedef struct redisObject {  
  unsigned type:1; //逻辑类型  
  unsigned notused:2;     /* Not used */  
  unsigned encoding:4; //物理存储类型  
  unsigned lru:22;        /* lru time (relative to server.lruclock) */  
  int refcount;  
  void *ptr;  //具体数据  
} robj;  

如下是rehash方法的源码

rehash 操作不是一次性完成,而是采用渐进方式,这是为了避免一次性执行过多的 rehash 操作给服务器带来过大的负担。

  • 渐进式 rehash 通过记录 dict 的 rehashidx 完成,它从0开始然后每执行一次rehash都会递增。例如在一次 rehash 中,要把 dict[0] rehash到dict[1],这一次会把 dict[0] 上 table[rehashidx] 的键值对 rehash 到 dict[1] 上,dict[0] 的 table[rehashidx] 指向 null,并令 rehashidx++。
  • 在 rehash 期间,每次对字典执行添加、删除、查找或者更新操作时,都会执行一次渐进式 rehash。
  • 采用渐进式 rehash 会导致字典中的数据分散在两个 dictht 上,因此对字典的操作也需要到对应的 dictht 去执行。
int dictRehash(dict *d, int n) {
   int empty_visits = n * 10; /* Max number of empty buckets to visit. */
   if (!dictIsRehashing(d)) return 0;

   while (n-- && d->ht[0].used != 0) {
       dictEntry *de, *nextde;

       /* Note that rehashidx can't overflow as we are sure there are more
        * elements because ht[0].used != 0 */
       assert(d->ht[0].size > (unsigned long) d->rehashidx);
       while (d->ht[0].table[d->rehashidx] == NULL) {
           d->rehashidx++;
           if (--empty_visits == 0) return 1;
       }
       de = d->ht[0].table[d->rehashidx];
       /* Move all the keys in this bucket from the old to the new hash HT */
       while (de) {
           uint64_t 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;
       d->rehashidx++;
   }

   /* Check if we already rehashed the whole table... */
   if (d->ht[0].used == 0) {
       zfree(d->ht[0].table);
       d->ht[0] = d->ht[1];
       _dictReset(&d->ht[1]);
       d->rehashidx = -1;
       return 0;
   }

   /* More to rehash... */
   return 1;
}

那底层数据的有序性是如何实现的呢?

跳跃表是有序集合的底层实现之一。

  • 跳跃表是基于多指针有序链表实现的,可以看成多个有序链表。
  • 跳跃表是一种随机化数据结构,查找、添加、删除操作都可以在对数期望时间下完成。
  • 跳跃表目前在 Redis 的唯一作用,就是作为有序集类型的底层数据结构(之一,另一个构成有序集的结构是字典)。
  • 与红黑树等平衡树相比,跳跃表具有以下优点:
    • 插入速度非常快速,因为不需要平衡树的旋转操作;
    • 更容易实现;
    • 支持无锁操作。

跳跃表的定义可以在任何一本算法或数据结构的书中找到, 在这不介绍跳跃表的具体实现方式或者具体的算法。推荐一篇漫画,可以快速理解跳跃表,想要深入理解跳跃表,推荐一篇博客

posted @ 2018-06-23 11:37  上帝爱吃苹果-Soochow  阅读(1611)  评论(0编辑  收藏  举报