一致性哈希算法与传统哈希算法的对比

1. 传统哈希算法

传统的哈希算法比较均匀的将数据分配到节点上。它依赖的hash算法（实现用的是md5算法）能够比较随机的分布。

from hashlib import md5
from struct import unpack_from

ITEMS = 10000000
NODES = 100

node_stat = [0 for i in range(NODES)]

for item in range(ITEMS):
    k = md5(str(item)).digest()
    h = unpack_from(">I", k)[0]
    n = h % NODES
    node_stat[n] += 1

但是存在一个问题，传统的哈希算法使用节点数取余的方法，强依赖节点的数目，因此，当节点数改变时，数据项所对应的节点会发生剧烈变化。

from hashlib import md5
from struct import unpack_from

ITEMS = 10000000
NODES = 100
NEW_NODES = 101

change = 0

for item in range(ITEMS):
    k = md5(str(item)).digest()
    h = unpack_from(">I", k)[0]
    n = h % NODES
    n_new = h % NEW_NODES
    if n_new != n:
        change += 1

 

2. 一致性哈希算法

而一致性哈希算法具有许多优点，被广泛应用。当增加或者删除节点时，对于大多数数据项，一致性哈希算法保证原来分配到的某个节点，现在仍然应该分配到那个节点。

from hashlib import md5
from struct import unpack_from
from bisect import bisect_left

ITEMS = 10000000
NODES = 100
NEW_NODES = 101

change = 0
ring = []
new_ring = []

def _hash(value):
    k = md5(str(value)).digest()
    ha = unpack_from(">I", k)[0]
    return ha

for n in range(NODES):
    ring.append(_hash(n))
    ring.sort()

for n in range(NEW_NODES):
    new_ring.append(_hash(n))
    new_ring.sort()

for item in range(ITEMS):
    h = _hash(item)
    n = bisect_left(ring, h) % NODES
    new_n = bisect_left(new_ring, h) % NEW_NODES
    if new_n != n:
        change += 1

一致性哈希算法也有缺点，数据在节点上分布不均匀。和传统哈希算法相比，数据本身的哈希值不变，变化的是数据哈希值应该映射到哪个节点的算法。

from hashlib import md5
from struct import unpack_from
from bisect import bisect_left

ITEMS = 10000000
NODES = 100

node_stat = [0 for i in range(NODES)]
ring = []
hash2node = {}

def _hash(value):
    k = md5(str(value)).digest()
    ha = unpack_from(">I", k)[0]
    return ha

for n in range(NODES):
    h = _hash(n)
    ring.append(h)
    ring.sort()
    hash2node[h] = n

for item in range(ITEMS):
    h = _hash(item)
    n = bisect_left(ring, h) % NODES
    node_stat[hash2node[ring[n]]] += 1

 

为了解决数据分布不均匀的问题，一致性哈希算法引入虚拟节点机制。

虚拟节点是实际节点（机器）在哈希空间的复制，每个实际节点（机器）对应若干个虚拟节点。