一致性hash算法

來源：http://www.jianshu.com/p/e8fb89bb3a61

一致性Hash用於分布式緩存系統，將Key值映射到具體機器Ip上，並且增加和刪除1台機器的數據移動量較小，對現網影響較小。

基本場景

比如你有 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 所示的那樣。

circle space

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

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

object

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;

cache

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 。

  
  

  圖 4 Cache B 被移除后的 cache 映射

• 5.2 添加 cache
  再考慮添加一台新的 cache D 的情況，假設在這個環形 hash 空間中， cache D 被映射在對象 object2 和object3 之間。這時受影響的將僅是那些沿 cache D 逆時針遍歷直到下一個 cache （ cache B ）之間的對象（它們是也本來映射到 cache C 上對象的一部分），將這些對象重新映射到 cache D 上即可。

因此這里僅需要變動對象 object2 ，將其重新映射到 cache D 上；參見圖 5 。

圖 5 添加 cache D 后的映射關系

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 。

圖 6 引入“虛擬節點”后的映射關系

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

圖 7 查詢對象所在 cache

“虛擬節點”的 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