（轉）一致性Hash算法在Memcached中的應用

本文轉載自查看原文 2015-05-27 10:53 1799 Memcached

前言

　　大家應該都知道Memcached要想實現分布式只能在客戶端來完成,目前比較流行的是通過一致性hash算法來實現.常規的方法是將 server的hash值與server的總台數進行求余,即hash%N,這種方法的弊端是當增減服務器時,將會有較多的緩存需要被重新分配且會造成緩存分配不均勻的情況(有可能某一台服務器分配的很多,其它的卻很少).

　　今天分享一種叫做”ketama”的一致性hash算法,它通過虛擬節點的概念和不同的緩存分配規則有效的抑制了緩存分布不均勻，並最大限度地減少服務器增減時緩存的重新分布。

實現思路

　　假設我們現在有N台Memcached的Server,如果我們用統一的規則對memcached進行Set,Get操作. 使具有不同key的object很均衡的分散存儲在這些Server上,Get操作時也是按同樣規則去對應的Server上取出object,這樣各個 Server之間不就是一個整體了嗎?

那到底是一個什么樣的規則?

　　如下圖所示,我們現在有5台(A,B,C,D,E)Memcached的Server,我們將其串聯起來形成一個環形,每一台Server都代表圓環上的一個點,每一個點都具有唯一的Hash值,這個圓環上一共有2^32個點.

那么該如何確定每台Server具體分布在哪個點上? 這里我們通過”Ketama”的Hash算法來計算出每台Server的Hash值,拿到Hash值后就可以對應到圓環上點了.(可以用Server的IP地址作為Hash算法的Key.)

　　這樣做的好處是,如下圖當我新增Server F時,那么我只需要將hash值落在C和F之間的object從原本的D上重新分配到F上就可以了,其它的server上的緩存不需要重新分配,並且新增的Server也能及時幫忙緩沖其它Server的壓力.

　　到此我們已經解決了增減服務器時大量緩存需要被重新分配的弊端.那該如何解決緩存分配不均勻的問題呢?因為現在我們的server只占據圓環上的6個點,而圓環上總共有2^32個點,這極其容易導致某一台server上熱點非常多，某一台上熱點很少的情況.

　　”虛擬節點”的概念很好的解決了這種負載不均衡的問題.通過將每台物理存在的Server分割成N個虛擬的Server節點(N通常根據物理 Server個數來定,這里有個比較好的閾值為250).這樣每個物理Server實際上對應了N個虛擬的節點. 存儲點多了,各個Server的負載自然要均衡一些.就像地鐵站出口一樣,出口越多,每個出口出現擁擠的情況就會越少.

　　代碼實現:

 1 //保存所有虛擬節點信息, key : 虛擬節點的hash key, value: 虛擬節點對應的真實server
 2         private Dictionary<uint, string> hostDictionary = new Dictionary<uint, string>();
 3         //保存所有虛擬節點的hash key, 已按升序排序
 4         private uint[] ketamaHashKeys = new uint[] { };
 5         //保存真實server主機地址
 6         private string[] realHostArr = new string[] { };
 7         //每台真實server對應虛擬節點個數
 8         private int VirtualNodeNum = 250;
 9 
10         public KetamaVirtualNodeInit(string[] hostArr)
11         {
12             this.realHostArr = hostArr;
13             this.InitVirtualNodes();
14         }
15 
16         /// <summary>
17         /// 初始化虛擬節點
18         /// </summary>
19         private void InitVirtualNodes()
20         {
21             hostDictionary = new Dictionary<uint, string>();
22             List<uint> hostKeys = new List<uint>();
23             if (realHostArr == null || realHostArr.Length == 0)
24             {
25                 throw new Exception("不能傳入空的Server集合");
26             }
27 
28             for (int i = 0; i < realHostArr.Length; i++)
29             {
30                 for (int j = 0; j < VirtualNodeNum; j++)
31                 {
32                     byte[] nameBytes = Encoding.UTF8.GetBytes(string.Format("{0}-node{1}", realHostArr[i], j));
33                     //調用Ketama hash算法獲取hash key
34                     uint hashKey = BitConverter.ToUInt32(new KetamaHash().ComputeHash(nameBytes), 0);
35                     hostKeys.Add(hashKey);
36                     if (hostDictionary.ContainsKey(hashKey))
37                     {
38                         throw new Exception("創建虛擬節點時發現相同hash key,請檢查是否傳入了相同Server");
39                     }
40                     hostDictionary.Add(hashKey, realHostArr[i]);
41                 }
42             }
43 
44             hostKeys.Sort();
45             ketamaHashKeys = hostKeys.ToArray();
46         }

一致性hash算法的分配規則

　　到此我們已經知道了所有虛擬節點的Hash值, 現在讓我們來看下當我們拿到一個對象時如何存入Server, 或是拿到一個對象的Key時該如何取出對象.

Set一個對象時,先將對象的Key作為”Ketama”算法的Key,計算出Hash值后我們需要做下面幾個步驟.

1:首先檢查虛擬節點當中是否有與當前對象Hash值相等的,如有則直接將對象存入那個Hash值相等的節點,后面的步驟就不繼續了.

2:如沒有,則找出第一個比當前對象Hash值要大的節點,(節點的Hash值按升序進行排序,圓環上對應按照順時針來排列),即離對象最近的節點,然后將對象存入該節點.

3:如果沒有找到Hash值比對象要大的Server,證明對象的Hash值是介於最后一個節點和第一個節點之間的,也就是圓環上的E和A之間.這種情況就直接將對象存入第一個節點,即A.

　　代碼實現:　　

 1 /// <summary>
 2         /// 根據hash key 獲取對應的真實Server
 3         /// </summary>
 4         /// <param name="hash"></param>
 5         /// <returns></returns>
 6         public string GetHostByHashKey(string key)
 7         {
 8             byte[] bytes = Encoding.UTF8.GetBytes(key);
 9             uint hash = BitConverter.ToUInt32(new KetamaHash().ComputeHash(bytes), 0);
10 
11             //尋找與當前hash值相等的Server. 
12             int i = Array.BinarySearch(ketamaHashKeys, hash);
13 
14             //如果i小於零則表示沒有hash值相等的虛擬節點
15             if (i < 0)
16             {
17                 //將i繼續按位求補,得到數組中第一個大於當前hash值的虛擬節點
18                 i = ~i;
19 
20                 //如果按位求補后的i大於等於數組的大小,則表示數組中沒有大於當前hash值的虛擬節點
21                 //此時直接取第一個server
22                 if (i >= ketamaHashKeys.Length)
23                 {
24                     i = 0;
25                 }
26             }
27 
28             //根據虛擬節點的hash key 返回對應的真實server host地址
29             return hostDictionary[ketamaHashKeys[i]];
30         }

Get一個對象,同樣也是通過”Ketama”算法計算出Hash值,然后與Set過程一樣尋找節點,找到之后直接取出對象即可.

那么這個”Ketama”到底長什么樣呢,讓我們來看看代碼實現.

 1 /// <summary>
 2     ///  Ketama hash加密算法
 3     ///  關於HashAlgorithm參見MSDN鏈接
 4     ///  http://msdn.microsoft.com/zh-cn/library/system.security.cryptography.hashalgorithm%28v=vs.110%29.aspx
 5     /// </summary>
 6     public class KetamaHash : HashAlgorithm
 7     {
 8 
 9         private static readonly uint FNV_prime = 16777619;
10         private static readonly uint offset_basis = 2166136261;
11 
12         protected uint hash;
13 
14         public KetamaHash()
15         {
16             HashSizeValue = 32;
17         }
18 
19         public override void Initialize()
20         {
21             hash = offset_basis;
22         }
23 
24         protected override void HashCore(byte[] array, int ibStart, int cbSize)
25         {
26             int length = ibStart + cbSize;
27             for (int i = ibStart; i < length; i++)
28             {
29                 hash = (hash * FNV_prime) ^ array[i];
30             }
31         }
32 
33         protected override byte[] HashFinal()
34         {
35             hash += hash << 13;
36             hash ^= hash >> 7;
37             hash += hash << 3;
38             hash ^= hash >> 17;
39             hash += hash << 5;
40             return BitConverter.GetBytes(hash);
41         }
42     }