淺談一致性Hash原理及應用

　　在講一致性Hash之前我們先來討論一個問題。

　　問題：現在有億級用戶，每日產生千萬級訂單，如何將訂單進行分片分表？

　　小A：我們可以按照手機號的尾數進行分片，同一個尾數的手機號寫入同一片/同一表中。

　　大佬：我希望通過會員ID來查詢這個會員的所有訂單信息，按照手機號分片/分表的話，前提是需要該用戶的手機號保持不變，並且在查詢訂單列表時需要提前查詢該用戶的手機號，利用手機號尾數不太合理。

　　小B：按照大佬的思路，我們需要找出一個唯一不變的屬性來進行分片/分表。

　　大佬：迷之微笑~

　　小B：（信心十足）會員在我們這邊保持不變的就是會員ID（int），我們可以通過會員ID的尾數進行分片/分表

　　小C：盡然我們可以用會員ID尾數進行分片/分表，那就用取模的方式來進行分片/分表，通過取模的方式可以達到很好的平衡性。示意圖如下：

 　　

　　大佬：嗯嗯嗯，在不考慮會員冷熱度的情況下小B和小C說的方案絕佳；但是往往我們的會員有冷熱度和僵屍會員，通過取模的方式往往會出現某個分片數據異常高，部分分片數據異常低，導致平衡傾斜。示意圖如下：

　　

　　大佬：當出現某個分片/分表達到極限時我們需要添加片/表，此時發現我們無法正常添加片/表。因為一旦添加片/或表的時候會導致絕大部分數據錯亂，按照原先的取模方式是無法正常獲取數據的。示意圖如下

　　

 

 

添加分片/分表前4,5,6會員的訂單分別存儲在A，B，C上，當添加了片/表的時候在按照（會員ID%N）方式取模去取數據4,5,6會員的訂單數據時發現無法取到訂單數據，因為此時4,5,6這三位會員數據分布存在了D，E，A上，具體示意圖如下： 

　　

　　大佬：所以通過取模的方式也會存在缺陷；好了接下來我們來利用一致hash原理的方式來解決分片/分表的問題。

 首先什么是一致性哈希算法?一致性哈希算法(Consistent Hashing Algorithm)是一種分布式算法，常用於負載均衡。Memcached client也選擇這種算法，解決將key-value均勻分配到眾多Memcached server上的問題。它可以取代傳統的取模操作，解決了取模操作無法應對增刪Memcached Server的問題(增刪server會導致同一個key,在get操作時分配不到數據真正存儲的server，命中率會急劇下降)。

 　　還以上述問題為例，假如我們有10片，我們利用Hash算法將每一片算出一個Hash值，而這些Hash點將被虛擬分布在Hash圓環上，理論視圖如下：　　

　　

　　按照順時針的方向，每個點與點之間的弧形屬於每個起點片的容量，然后按照同樣的Hash計算方法對每個會員ID進行Hash計算得出每個Hash值然后按照區間進行落片/表，以保證數據均勻分布。

如果此時需要在B和C之間新增一片/表(B1)的話，就不會出現按照取模形式導致數據幾乎全部錯亂的情況，僅僅是影響了(B1,C)之間的數據，這樣我們清洗出來也就比較方便，也不會出現數據大批量

癱瘓。

　　但是如果我們僅僅是將片/表進行計算出Hash值之后，這些點分布並不是那么的均勻，比如就會下面的這種情況，導致區間傾斜。如圖

　　這個時候虛擬節點就此誕生，下面讓我們來看一下虛擬節點在一致性Hash中的作用。當我們在Hash環上新增若干個點，那么每個點之間的距離就會接近相等。按照這個思路我們可以新增若干個

片/表，但是成本有限，我們通過復制多個A、B、C的副本({A1-An},{B1-Bn},{C1-Cn})一起參與計算，按照順時針的方向進行數據分布，按照下圖示意:

　　

此時A=[A,C1)&[A1,C2)&[A2,B4)&[A3,A4)&[A4,B1)；B=[B,A1)&[B2,C)&[B3,C3)&[B4,C4)&[B1,A)；C=[C1,B)&[C2,B2)&[C,B3)&[B3,C3)&[C4,A3)；由圖可以看出分布點越密集，平衡性約好。

 

我寫了一個測試用例，10台服務器，1000個虛擬節點，根據算法對50000數據精細計算得出每台機器上具體數據的分布

192.168.1.0:5011
192.168.1.1:5058
192.168.1.2:5187
192.168.1.3:4949
192.168.1.4:5097
192.168.1.5:4939
192.168.1.6:5129
192.168.1.7:4824
192.168.1.8:4957
192.168.1.9:4849

我從計算結果中打印出了20數據分布的機器情況具體如下：

ConsistentHashTest1202:192.168.1.8
ConsistentHashTest1203:192.168.1.4
ConsistentHashTest1204:192.168.1.9
ConsistentHashTest1205:192.168.1.9
ConsistentHashTest1206:192.168.1.4
ConsistentHashTest1207:192.168.1.3
ConsistentHashTest1208:192.168.1.8
ConsistentHashTest1209:192.168.1.2
ConsistentHashTest1210:192.168.1.0
ConsistentHashTest1211:192.168.1.0
ConsistentHashTest1212:192.168.1.6
ConsistentHashTest1213:192.168.1.2
ConsistentHashTest1214:192.168.1.7
ConsistentHashTest1215:192.168.1.1
ConsistentHashTest1216:192.168.1.9
ConsistentHashTest1217:192.168.1.0
ConsistentHashTest1218:192.168.1.4
ConsistentHashTest1219:192.168.1.4

然后我剔除其中一台服務器“192.168.1.8”，在根據算法進行計算並且同事打印出和上述一直的20條數據的分布情況

192.168.1.0:5011
192.168.1.1:5058
192.168.1.2:5187
192.168.1.3:4949
192.168.1.4:5097
192.168.1.5:4939
192.168.1.6:5129
192.168.1.7:4824
192.168.1.8:4957
192.168.1.9:4849

ConsistentHashTest1202:192.168.1.8
ConsistentHashTest1203:192.168.1.4
ConsistentHashTest1204:192.168.1.9
ConsistentHashTest1205:192.168.1.9
ConsistentHashTest1206:192.168.1.4
ConsistentHashTest1207:192.168.1.3
ConsistentHashTest1208:192.168.1.8
ConsistentHashTest1209:192.168.1.2
ConsistentHashTest1210:192.168.1.0
ConsistentHashTest1211:192.168.1.0
ConsistentHashTest1212:192.168.1.6
ConsistentHashTest1213:192.168.1.2
ConsistentHashTest1214:192.168.1.7
ConsistentHashTest1215:192.168.1.1
ConsistentHashTest1216:192.168.1.9
ConsistentHashTest1217:192.168.1.0
ConsistentHashTest1218:192.168.1.4
ConsistentHashTest1219:192.168.1.4

根據兩次的計算結果對比我們發現減少機器后，每台機器上的數據量增加了，但是原先分布在具體機器上的數據，並沒有變化。

 

但是一致性Hash的分布還會和數據源有關，可能會出現數據傾斜的情況。

 具體C#測試代碼如下：

https://github.com/tcued/LearningDemo

using System;
using System.Collections.Generic;
using System.Data.HashFunction;
using System.Data.HashFunction.xxHash;
using System.Linq;

namespace HashTest
{
    public class ConsistentHash1
    {
        /// <summary>
        /// 虛擬節點數
        /// </summary>
        private static readonly int VirturalNodeNum = 1000;

        /// <summary> 
        /// 服務器IP
        /// </summary>
        private static readonly string[] Nodes =
        {
            "192.168.1.0",
            "192.168.1.1",
            "192.168.1.2",
            "192.168.1.3",
            "192.168.1.4",
            "192.168.1.5",
            "192.168.1.6",
            "192.168.1.7",
            "192.168.1.8",
            "192.168.1.9"
        };

        /// <summary>
        /// 按照一致性Hash進行分組
        /// </summary>
        private static readonly IDictionary<uint, string> ConsistentHashNodes = new SortedDictionary<uint, string>();

        private static uint[] _nodeKeys = null;
        static void Main(string[] args)
        {
            ComputeNode();
            Print();
            Console.ReadLine();
        }

        private static void Print()
        {
            IDictionary<string, int> result = new SortedDictionary<string, int>();
            for (int i = 0; i < 50000; i++)
            {
                var node = Get("ConsistentHashTest" + i);
                if (result.TryGetValue(node, out var count))
                {
                    result[node] = count + 1;
                }
                else
                {
                    result[node] = 1;
                }
                if (i > 1200 && i < 1220)
                {
                    Console.WriteLine($"ConsistentHashTest{i}:{node}");
                }
            }

            foreach (var node in result)
            {
                Console.WriteLine($"{node.Key}:{node.Value}");
            }
        }

        private static void ComputeNode()
        {
            foreach (var node in Nodes)
            {
                AddNode(node);
            }

            _nodeKeys = ConsistentHashNodes.Keys.ToArray();
        }

        private static void AddNode(string node)
        {
            for (int i = 0; i < VirturalNodeNum; i++)
            {
                var key = node + ":" + i;
                var hashValue = ComputeHash(key);
                if (!ConsistentHashNodes.ContainsKey(hashValue))
                {
                    ConsistentHashNodes.Add(hashValue, node);
                }
            }
        }

        private static uint ComputeHash(string virturalNode)
        {
            var hashFunction = xxHashFactory.Instance.Create();
            var hashValue = hashFunction.ComputeHash(virturalNode);
            return BitConverter.ToUInt32(hashValue.Hash, 0);
        }

        private static string Get(string item)
        {
            var hashValue = ComputeHash(item);
            var index = GetClockwiseNearestNode(hashValue);
            return ConsistentHashNodes[_nodeKeys[index]];
        }

        private static int GetClockwiseNearestNode(uint hash)
        {
            int begin = 0;
            int end = _nodeKeys.Length - 1;

            if (_nodeKeys[end] < hash || _nodeKeys[0] > hash)
            {
                return 0;
            }

            while ((end - begin) > 1)
            {
                var mid = (end + begin) / 2;
                if (_nodeKeys[mid] >= hash) end = mid;
                else begin = mid;
            }

            return end;
        }
    }
}