經典好文：一致性HASH算法詳解，看不懂你打我

基本場景

好比你有 N 個 cache 服務器（後面簡稱 cache ），那麼如何將一個對象 object 映射到 N 個 cache 上呢，你極可能會採用相似下面的通用方法計算 object 的 hash 值，而後均勻的映射到到 N 個 cache ；

求餘算法: hash(object)%N

一切都運行正常，再考慮以下的兩種狀況； 1 一個 cache 服務器 m down 掉了（在實際應用中必需要考慮這種狀況），這樣全部映射到 cache m 的對象都會失效，怎麼辦，須要把 cache m 從 cache 中移除，這時候 cache 是 N-1 臺，映射公式變成了 hash(object)%(N-1) ； 2 因爲訪問加劇，須要添加 cache ，這時候 cache 是 N+1 臺，映射公式變成了 hash(object)%(N+1) ； 1 和 2 意味着什麼？這意味着忽然之間幾乎全部的 cache 都失效了。對於服務器而言，這是一場災難，洪水般的訪問都會直接衝向後臺服務器； 再來考慮第三個問題，因爲硬件能力愈來愈強，你可能想讓後面添加的節點多作點活，顯然上面的 hash 算法也作不到。   有什麼方法能夠改變這個情況呢，這就是 consistent hashing...

hash 算法和單調性

   Hash 算法的一個衡量指標是單調性（ Monotonicity ），定義以下： 單調性是指若是已經有一些內容經過哈希分派到了相應的緩衝中，又有新的緩衝加入到系統中。哈希的結果應可以保證原有已分配的內容能夠被映射到新的緩衝中去，而不會被映射到舊的緩衝集合中的其餘緩衝區。 容易看到，上面的簡單求餘算法 hash(object)%N 難以知足單調性要求。

Consistent Hashing 一致性hash的原理

consistent hashing 是一種 hash 算法，簡單的說，在移除 / 添加一個 cache 時，它可以儘量小的改變已存在key 映射關係，儘量的知足單調性的要求。

1. 環形hash 空間

考慮一般的 hash 算法都是將 value 映射到一個 32 爲的 key 值，也便是 0~2^32-1 次方的數值空間；咱們能夠將這個空間想象成一個首（ 0 ）尾（ 2^32-1 ）相接的圓環，以下面圖 1 所示的那樣。

2.  把須要緩存的內容(對象)映射到hash 空間

接下來考慮 4 個對象 object1~object4 ，經過 hash 函數計算出的 hash 值 key 在環上的分佈如圖 2 所示。 hash(object1) = key1; … … hash(object4) = key4;

3 .把服務器(節點)映射到hash 空間

Consistent hashing 的基本思想就是將對象和 cache 都映射到同一個 hash 數值空間中，而且使用相同的 hash算法。 假設當前有 A,B 和 C 共 3 臺服務器(節點)，那麼其映射結果將如圖 3 所示，他們在 hash 空間中，以對應的 hash 值排列。 通常的方法可使用 服務器(節點) 機器的 IP 地址或者機器名做爲 hash輸入。 hash(cache A) = key A; … … hash(cache C) = key C;

4 .把對象映射到cache

如今cache和對象都已經經過同一個 hash 算法映射到 hash 數值空間中了，接下來要考慮的就是如何將對象映射到 cache 上面了。 在這個環形空間中，若是沿着順時針方向從對象的 key 值出發，直到碰見一個 cache ，那麼就將該對象存儲在這個 cache 上，由於對象和 cache 的 hash 值是固定的，所以這個 cache 必然是惟一和肯定的。這樣不就找到了對象和 cache 的映射方法了嗎？！ 依然繼續上面的例子，那麼根據上面的方法，對象 object1 將被存儲到 cache A 上； object2 和object3 對應到 cache C ； object4 對應到 cache B ；

5. 考察cache 的變更

前面講過，經過 hash 而後求餘的方法帶來的最大問題就在於不能知足單調性，當 cache 有所變更時， cache會失效，進而對後臺服務器形成巨大的衝擊，如今就來分析分析 consistent hashing 算法。

• 5.1 移除 cache 考慮假設 cache B 掛掉了，根據上面講到的映射方法，這時受影響的將僅是那些沿 cache B 逆時針遍歷直到下一個 cache （ cache C ）之間的對象，也便是原本映射到 cache B 上的那些對象。 所以這裏僅須要變更對象 object4 ，將其從新映射到 cache C 上便可；參見圖 4 。

  

• 5.2 添加 cache 再考慮添加一臺新的 cache D 的狀況，假設在這個環形 hash 空間中， cache D 被映射在對象 object2 和object3 之間。這時受影響的將僅是那些沿 cache D 逆時針遍歷直到下一個 cache （ cache B ）之間的對象（它們是也原本映射到 cache C 上對象的一部分），將這些對象從新映射到 cache D 上便可。   所以這裏僅須要變更對象 object2 ，將其從新映射到 cache D 上；參見圖 5 。

  

6 .虛擬節點

考量 Hash 算法的另外一個指標是平衡性 (Balance) ，定義以下： 平衡性   平衡性是指哈希的結果可以儘量分佈到全部的緩衝中去，這樣可使得全部的緩衝空間都獲得利用。 hash 算法並非保證絕對的平衡，若是 cache 較少的話，對象並不能被均勻的映射到 cache 上，好比在上面的例子中，僅部署 cache A 和 cache C 的狀況下，在 4 個對象中， cache A 僅存儲了 object1 ，而 cache C 則存儲了object2 、 object3 和 object4 ；分佈是很不均衡的。 爲了解決這種狀況， consistent hashing 引入了「虛擬節點」的概念，它能夠以下定義： 「虛擬節點」（ virtual node ）是實際節點在 hash 空間的複製品（ replica ），一實際個節點對應了若干個「虛擬節點」，這個對應個數也成爲「複製個數」，「虛擬節點」在 hash 空間中以 hash 值排列。 仍以僅部署 cache A 和 cache C 的狀況爲例，在圖 4 中咱們已經看到， cache 分佈並不均勻。如今咱們引入虛擬節點，並設置「複製個數」爲 2 ，這就意味着一共會存在 4 個「虛擬節點」， cache A1, cache A2 表明了 cache A； cache C1, cache C2 表明了 cache C ；假設一種比較理想的狀況，參見圖 6 。

  此時，對象到「虛擬節點」的映射關係爲： objec1->cache A2 ； objec2->cache A1 ； objec3->cache C1 ； objec4->cache C2 ； 所以對象 object1 和 object2 都被映射到了 cache A 上，而 object3 和 object4 映射到了 cache C 上；平衡性有了很大提升。 引入「虛擬節點」後，映射關係就從 { 對象 -> 節點 } 轉換到了 { 對象 -> 虛擬節點 } 。查詢物體所在 cache 時的映射關係如圖 7 所示。

「虛擬節點」的 hash 計算能夠採用對應節點的 IP 地址加數字後綴的方式。例如假設 cache A 的 IP 地址爲202.168.14.241 。 引入「虛擬節點」前，計算 cache A 的 hash 值： Hash(「202.168.14.241」); 引入「虛擬節點」後，計算「虛擬節」點 cache A1 和 cache A2 的 hash 值： Hash(「202.168.14.241#1」);  // cache A1 Hash(「202.168.14.241#2」);  // cache A2

代碼實現DEMO

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from zlib import crc32
import memcache

class HashConsistency(object):
    def __init__(self, nodes=None, replicas=5):
        # 虛擬節點與真實節點對應關係
        self.nodes_map = []
        # 真實節點與虛擬節點的字典映射
        self.nodes_replicas = {}
        # 真實節點
        self.nodes = nodes
        # 每一個真實節點建立的虛擬節點的個數
        self.replicas = replicas

        if self.nodes:
            for node in self.nodes:
                self._add_nodes_map(node)
            self._sort_nodes()

    def get_node(self, key):
        """ 根據KEY值的hash值，返回對應的節點 算法是： 返回最先比key_hash大的節點 """
        key_hash = abs(crc32(key))
        #print '(%s' % key_hash
        for node in self.nodes_map:
            if key_hash > node[0]:
                continue
            return node
        return None

    def add_node(self, node):
        # 添加節點
        self._add_nodes_map(node)
        self._sort_nodes()

    def remove_node(self, node):
        # 刪除節點
        if node not in self.nodes_replicas.keys():
            pass
        discard_rep_nodes = self.nodes_replicas[node]
        self.nodes_map = filter(lambda x: x[0] not in discard_rep_nodes, self.nodes_map)

    def _add_nodes_map(self, node):
        # 增長虛擬節點到nodes_map列表
        nodes_reps = []
        for i in xrange(self.replicas):
            rep_node = '%s_%d' % (node, i)
            node_hash = abs(crc32(rep_node))
            self.nodes_map.append((node_hash, node))
            nodes_reps.append(node_hash)
        # 真實節點與虛擬節點的字典映射
        self.nodes_replicas[node] = nodes_reps

    def _sort_nodes(self):
        # 按順序排列虛擬節點
        self.nodes_map = sorted(self.nodes_map, key=lambda x:x[0])


memcache_servers = [
    '127.0.0.1:7001',
    '127.0.0.1:7002',
    '127.0.0.1:7003',
    '127.0.0.1:7004',
]

h = HashConsistency(memcache_servers)

for k in h.nodes_map:
    print k

mc_servers_dict = {}
for ms in  memcache_servers:
    mc = memcache.Client([ms], debug=0)
    mc_servers_dict[ms] = mc

# 循環10此給memcache 添加key，這裏使用了一致性hash，那麼key將會根據hash值落點到對應的虛擬節點上
for i in xrange(10):
    key = 'key_%s' % i
    print key
    server = h.get_node(key)[1]
    mc = mc_servers_dict[server]
    mc.set(key, i)
    print 'SERVER :%s' % server
    print mc
複製代碼

關於我

若是文章對你有收穫，能夠收藏轉發，這會給我一個大大鼓勵喲！ 另外能夠關注我公衆號【碼農富哥】 (coder2025)，我會持續輸出原創的算法，計算機基礎文章！