数据结构 - hashtable

Thu, 12 Dec 2019 13:50:26 +0800

背景#

最近一直在看《redis设计与实现》，其中讲了redis中使用到的数据结构如：sds, ziplist, skiplist, hashtable, intset, linkedlist等。读完第一部分之后，再结合github上的源码redis，本着好记性不如烂笔头的理念，便准备动手撸一遍。

redis中hashtable的特点#

链地址法解决hash冲突（除此以外，常见的冲突解决办法还有：再散列法/再哈希法/建立公共溢出区）
使用了murmur2哈希函数。
渐进式rehash，rehash过程并不是一步到位，而是在get/set/del 等操作中，穿插着完成。
自动扩容和自动收缩，通过阀值来控制扩容和收缩。
有2个bucket，其中0号bucket是最常用的，而1号只会在rehash过程中使用，一旦rehash完成，便不再使用。

解析和实现#

hashtable：是根据Key直接访问在内存存储位置的数据结构。如何根据key得到内存中的位置，就需要使用hash函数来从旁协助了。

hash函数：是一种从任何一种数据中创建小的数字“指纹”的方法。简单的说：hash(input) = 1122334455。

这里选择了golang来实现；murmur3 hash算法；

数据结构#

一图以蔽之：

// 对外暴露的hashtable
type LinkedDict struct {
	// 2个存储桶，0号正常使用，1号在rehash过程中使用；rehash完成之后，1号赋值给0号然后重置1号。
	ht [2]*hashtable
	// 初始值 -1，表示没有在rehash
	rehashIdx int
}

// 存储桶
type hashtable struct {
	// 底层“数组”
	table []*dictEntry
	size int
	sizemask int
	used int
}

// hashtable 元素定义
type dictEntry struct {
	key string
	value interface{}
	next *dictEntry
}

方法集#

hashtable常用的方法有 GET/SET/DELETE/ITER，接下来会在SET和DEL中介绍rehash的详细过程。

SET#

func (d *LinkedDict) Set(key string, value interface{}) {
	if d.ht[0].table == nil {
		d.ht[0].init(InitTableSize)
	}

	// isRehashing 判定：`rehashIdx != -1`
	// needRehash 判定: 装载因子 used / size > 1.0 时触发扩容rehash
	if !d.isRehashing() && d.needRehash() {
		// rehashGrowup 表示本次rehash是需要扩容，在配置ht[1].table时会扩展为当前的2倍
		// 反之则会缩减内存空间
		// startrehash 会设置 rehashIdx = 0, 标志rehash的进度
		d.startrehash(rehashGrowup) 
	}

	if d.isRehashing() {
		// 如果在rehash过程中，则完成一部分任务: 
		// 根据rehash的进度rehashIdx，选择搬移 d.ht[0].table[rehashIdx]部分的数据，添加到d.ht[1]中
		d.steprehash()
	}

	// 上述工作完成之后，就可以考虑新增数据了
	hashkey := d.hashkey(key)
	if d.isRehashing() {
		// 如果在rehash过程中，毋庸考虑，直接新增到d.ht[1]中
		d.ht[1].insert(hashkey, newDictEntry(key, value, nil))
		return
	}

	// 反之，不在rehash过程中，则直接新增到d.ht[0]中
	d.ht[0].insert(hashkey, newDictEntry(key, value, nil))
	return
}

// 渐进式rehash，根据rehashIdx确定，要搬移那一部分的数据。
func (d *LinkedDict) steprehash() {
	entry := d.ht[0].table[d.rehashIdx]
	// 如果rehashIdx指向的侧链为空，则rehashIdx自增，直到找到有数据的侧链或者数据均搬移完成
	for entry == nil {
		d.rehashIdx++
		if d.rehashIdx > d.ht[0].sizemask {
			d.finishrehash()
			return
		}
		entry = d.ht[0].table[d.rehashIdx]
	}

	// 开始搬移动作
	// 遍历链表，将所有数据，新增到d.ht[1]中
	next := entry.next
	for entry != nil {
		entry.next = nil
		d.ht[1].insert(d.hashkey(entry.key), entry)
		if next == nil {
			break
		}
		entry = next
		next = next.next
	}

	// 释放d.ht[0].table[rehashIdx]链表：避免干扰查询；释放内存
	d.ht[0].table[d.rehashIdx] = nil
	d.rehashIdx++

	if d.rehashIdx > d.ht[0].sizemask {
		// 是否已经结束，如果结束则：
		// d.ht[0] = d.ht[1]
		// d.ht[1] = newHashTable()
		// rehashIdx = -1
		d.finishrehash()
	}
}

// 新增一个元素到到存储桶：
// 根据hash函数的结果(hashkey)对存储桶大小(size)取模得到结果(pos)；ht.table[pos]完成对链表的新增工作。
func (ht *hashtable) insert(hashkey uint64, item *dictEntry) {
	pos := hashkey % uint64(ht.size)
	entry := ht.table[pos]
	last := entry
	if entry == nil {
		ht.used++
		ht.table[pos] = item
		return
	}

	for entry != nil {
		if ht.keyCompare(entry.key, item.key) {
			// 如果key已经存在则覆盖旧值
			entry.value = item.value
			return
		}
		last = entry
		entry = entry.next
	}
	ht.used++
	last.next = item
}

总结：