Hash一致性算法在分佈式中的應用實踐

一、Hash算法與分佈式架構的發展

第一階段

考慮到單服務器不能承載，因此使用了分佈式架構，最初的算法爲 hash() mod n, hash()通常取用戶ID，n爲節點數。此方法容易實現且能夠滿足運營要求。缺點是當單點發生故障時，系統無法自動恢復。

第二階段
爲了解決單點故障，使用 hash() mod (n/2), 這樣任意一個用戶都有2個服務器備選，可由client隨機選取。由於不同服務器之間的用戶需要彼此交互，所以所有的服務器需要確切的知道用戶所在的位置。因此用戶位置被保存到memcached中。

當一臺發生故障，client可以自動切換到對應backup，由於切換前另外1臺沒有用戶的session，因此需要client自行重新登錄。

這個階段的設計存在以下問題
負載不均衡，尤其是單臺發生故障後剩下一臺會壓力過大。
不能動態增刪節點
節點發生故障時需要client重新登錄

第三階段
打算去掉硬編碼的hash() mod n 算法，改用一致性哈希(consistent hashing)分佈
假如採用Dynamo中的strategy 1
我們把每臺server分成v個虛擬節點，再把所有虛擬節點(n*v)隨機分配到一致性哈希的圓環上，這樣所有的用戶從自己圓環上的位置順時針往下取到第一個vnode就是自己所屬節點。當此節點存在故障時，再順時針取下一個作爲替代節點。

優點：發生單點故障時負載會均衡分散到其他所有節點，程序實現也比較優雅。

二、Hash 算法和單調性

Hash 算法的一個衡量指標是單調性（ Monotonicity ）

單調性是指如果已經有一些內容通過哈希分派到了相應的緩衝中，又有新的緩衝加入到系統中。哈希的結果應能夠保證原有已分配的內容可以被映射到新的緩衝中去，而不會被映射到舊的緩衝集合中的其他緩衝區。

容易看到，上面的簡單 hash 算法 hash(object)%N 難以滿足單調性要求。

三、一致性Hash 算法的原理

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

下面就來按照 5 個步驟簡單講講 consistent hashing 算法的基本原理。

3.1 環形hash 空間

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

圖 1 環形 hash 空間

3.2 把對象映射到hash 空間

接下來考慮 4 個對象 object1~object4 ，通過 hash 函數計算出的 hash 值 key 在環上的分佈如圖 2 所示。

hash(object1) = key1;

… …

hash(object4) = key4;

圖 2 4 個對象的 key 值分佈

3.3 把cache 映射到hash 空間

Consistent hashing 的基本思想就是將對象和 cache 都映射到同一個 hash 數值空間中，並且使用相同的hash 算法。

假設當前有 A,B 和 C 共 3 臺 cache ，那麼其映射結果將如圖 3 所示，他們在 hash 空間中，以對應的 hash值排列。

hash(cache A) = key A;

… …

hash(cache C) = key C;

圖 3 cache 和對象的 key 值分佈

 

說到這裏，順便提一下 cache 的 hash 計算，一般的方法可以使用 cache 機器的 IP 地址或者機器名作爲hash 輸入。

3.4 把對象映射到cache

現在 cache 和對象都已經通過同一個 hash 算法映射到 hash 數值空間中了，接下來要考慮的就是如何將對象映射到 cache 上面了。

在這個環形空間中，如果沿着順時針方向從對象的 key 值出發，直到遇見一個 cache ，那麼就將該對象存儲在這個 cache 上，因爲對象和 cache 的 hash 值是固定的，因此這個 cache 必然是唯一和確定的。這樣不就找到了對象和 cache 的映射方法了嗎？！

依然繼續上面的例子（參見圖 3 ），那麼根據上面的方法，對象 object1 將被存儲到 cache A 上； object2和 object3 對應到 cache C ； object4 對應到 cache B ；

3.5 考察cache 的變動

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

3.5.1 移除 cache

考慮假設 cache B 掛掉了，根據上面講到的映射方法，這時受影響的將僅是那些沿 cache B 逆時針遍歷直到下一個 cache （ cache C ）之間的對象，也即是本來映射到 cache B 上的那些對象。

因此這裏僅需要變動對象 object4 ，將其重新映射到 cache C 上即可；參見圖 4 。

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

3.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 後的映射關係

四、平衡性與虛擬節點

考量 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

五、Java實現

import java.util.Collection;
import java.util.SortedMap;
import java.util.TreeMap;

public class ConsistentHash<T> {

 private final HashFunction hashFunction;
 private final int numberOfReplicas;
 private final SortedMap<Integer, T> circle = new TreeMap<Integer, T>();

 public ConsistentHash(HashFunction hashFunction, int numberOfReplicas,
     Collection<T> nodes) {
   this.hashFunction = hashFunction;
   this.numberOfReplicas = numberOfReplicas;

   for (T node : nodes) {
     add(node);
   }
 }

 public void add(T node) {
   for (int i = 0; i < numberOfReplicas; i++) {
     circle.put(hashFunction.hash(node.toString() + i), node);
   }
 }

 public void remove(T node) {
   for (int i = 0; i < numberOfReplicas; i++) {
     circle.remove(hashFunction.hash(node.toString() + i));
   }
 }

 public T get(Object key) {
   if (circle.isEmpty()) {
     return null;
   }
   int hash = hashFunction.hash(key);
   if (!circle.containsKey(hash)) {
     SortedMap<Integer, T> tailMap = circle.tailMap(hash);
     hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
   }
   return circle.get(hash);
 }

}

整理內容來源：

http://www.codinglabs.org/html/consistent-hashing.html#more-79

http://blog.csdn.net/sparkliang/article/details/5279393

http://timyang.net/architecture/consistent-hashing-practice/

http://weblogs.java.net/blog/2007/11/27/consistent-hashing

http://blog.csdn.net/sparkliang/article/details/5279393 等等。。