了解一致性哈希算法

用途

一致性哈希算法是為了解決普通哈希算法的熱點問題，當使用普通哈希算法來切割數據到不同的緩存服務器時。
一旦緩存服務器的數量產生變化，客戶端向緩存服務器請求相應的數據就不會命中，轉而請求具體的數據庫服務器，從而造成 緩存擊穿。

下面我們來看一下使用普通哈希算法時所帶來的問題，假如我們擁有 10 台緩存服務器，那么我們在存放數據的時候可以對緩存數據項的 Key 進行哈希操作，取得其散列值，並將其與服務器數量進行取模運算，就可以得到一個服務器下標的數字。

服務器信息 = Hash(Key) % 10

例如我針對字符串 "140" 進行 SHA256 散列操作，得到 762818267，對 10 取模運算結果是 7 號服務器。但如果增加了一台服務器，那么就會變成對 11 取模,，其結果就是 2 號服務器，得到的位置完全不正確，造成取緩存的時候肯定不會命中。

原理

注意：

由於畫圖的時候粗心將服務器 C 的 IP 地址寫成了 192.168.100.102，其真實 IP 應該是 192.168.100.103，閱讀文章的時候請注意這個區別。

1.創建一個環，這個哈希環有 2^32 個節點。

2.求出服務器的哈希值，並將其與哈希環節點的數量取模，得到的值即是服務器節點在哈希環上的位置。

3.根據要存儲的數據項鍵值，求出其哈希值，與哈希環節點數量取模，得到在哈希環的位置。

4.根據數據項在哈希環的位置，順時針查找遇到的第一個服務器節點，將數據項存放到該服務器。

5.如果增加了一台服務器 D，只會影響 D 之前區間的數據。

上述情況僅適用於服務節點在哈希環上分布均勻的情況，如果哈希環上服務器節點的 分布位置不均勻，則會導致某個區間內的數據項的大量數據存放在一個服務器節點中。如下圖，A 緩存服務器就會接收大量請求，當該服務器崩潰掉之后，B 服務器，C 服務器會依次崩潰，這樣就會造成 服務器雪崩效應，整個緩存服務器集群都會癱瘓。

這種時候，我們可以引入虛擬節點來解決該問題。例如我們擁有 A、B、C 三台服務器，我們在哈希環上創建哈希服務器的時候，可以為其創建 N 個虛擬節點，這些虛擬節點都是指向真實服務器的 IP，這樣我們在哈希環上的服務器節點分布就會很均勻。

實現

在這里我們基於 C# 與 .NET Core 編寫一個 DEMO 代碼，用來演示上述情況，這里的代碼僅作演示使用，如果要應用到生產環境，請注意線程同步問題。

using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;

/*
 * 一致性哈希算法的 DEMO，主要用於演示一致性哈希算法的實現與實際應用。
 */

namespace ConsistentHashing.Startup
{
    public class NodeInfo
    {
        public string IPAddress { get; set; }
    }

    public class VirtualNodeInfo
    {
        public string NodeName { get; set; }

        public NodeInfo RealNodeInfo { get; set; }
    }

    public class ConsistentHashing
    {
        // 哈希環的大小
        private readonly int _ringCount;
        // 每個物理節點對應的虛擬節點數量
        private readonly int _virtualNodeCount;

        // 哈希環
        public readonly VirtualNodeInfo[] HashRing;

        public ConsistentHashing(int ringCount = int.MaxValue, int virtualNodeCount = 3)
        {
            _ringCount = ringCount;
            _virtualNodeCount = virtualNodeCount;
            HashRing = new VirtualNodeInfo[_ringCount];
        }

        public NodeInfo GetNode(string key)
        {
            var pos = Math.Abs(GetStandardHashCode(key) % _ringCount);
            // 順時針查找最近的節點
            return GetFirstNodeInfo(pos).RealNodeInfo;
        }

        /// <summary>
        /// 向哈希環上添加虛擬節點。
        /// </summary>
        public void AddNode(NodeInfo info)
        {
            for (int index = 0; index < _virtualNodeCount; index++)
            {
                // 哈希環上沒有物理節點，只有虛擬節點
                var virtualNodeName = $"{info.IPAddress}#{index}";
                var hashIndex = Math.Abs(GetStandardHashCode(virtualNodeName) % _ringCount);
                
                // 搜索空的哈希環位置
                var emptyIndex = GetEmptyNodeIndex(hashIndex);

                if (emptyIndex == -1)
                {
                    break;
                }
                
                HashRing[emptyIndex] = new VirtualNodeInfo{NodeName = virtualNodeName,RealNodeInfo = info};
            }
        }

        public void RemoveNode(NodeInfo info)
        {
            // 構建虛擬節點的 KEY
            var virtualNames = new List<string>();
            for (int i = 0; i < _virtualNodeCount; i++)
            {
                virtualNames.Add($"{info.IPAddress}#{i}");
            }

            for (int i = 0; i < HashRing.Length; i++)
            {
                if(HashRing[i] == null) continue;
                if (virtualNames.Contains(HashRing[i].NodeName)) HashRing[i] = null;
            }
        }

        /// <summary>
        /// 計算指定 KEY 的 HASH 值
        /// </summary>
        private int GetStandardHashCode(string key)
        {
            var sha1 = SHA256.Create();
            var hashValue = sha1.ComputeHash(Encoding.UTF8.GetBytes(key));
            return BitConverter.ToInt32(hashValue);
        }

        /// <summary>
        /// 循環遍歷哈希環，尋找空節點的索引，防止覆蓋存在的節點信息。
        /// </summary>
        private int GetEmptyNodeIndex(int startFindIndex)
        {
            while (true)
            {
                if (HashRing[startFindIndex] == null)
                {
                    return startFindIndex;
                }

                var nextIndex = GetNextNodeIndex(startFindIndex);
                // 說明已經遍歷了整個哈希環，說明沒有空的節點了。
                if (startFindIndex == nextIndex)
                {
                    return -1;
                }

                startFindIndex = nextIndex;
            }
        }

        /// <summary>
        /// 根據指定的索引，獲得哈希環的下一個索引。這里需要注意的是，因為哈希環是一個環形，當
        /// 當前位置為環的末尾時，應該從 0 開始查找。
        /// </summary>
        private int GetNextNodeIndex(int preIndex)
        {
            if (preIndex == HashRing.Length - 1) return 0;

            return ++preIndex;
        }

        private VirtualNodeInfo GetFirstNodeInfo(int currentIndex)
        {
            VirtualNodeInfo nodeInfo = null;
            int nextIndex = currentIndex;
            while (nodeInfo == null)
            {
                nodeInfo = HashRing[GetNextNodeIndex(nextIndex)];
                nextIndex += 1;
            }
            
            return nodeInfo;
        }
    }

    internal class Program
    {
        private static void Main(string[] args)
        {
            var consistentHashing = new ConsistentHashing(400,10);
            consistentHashing.AddNode(new NodeInfo {IPAddress = "192.168.1.101"});
            consistentHashing.AddNode(new NodeInfo {IPAddress = "192.168.1.102"});
            consistentHashing.AddNode(new NodeInfo {IPAddress = "192.168.1.103"});
            consistentHashing.AddNode(new NodeInfo {IPAddress = "192.168.1.104"});

            foreach (var node in consistentHashing.HashRing)
            {
                Console.WriteLine(node?.NodeName ?? "NULL");
            }

            // 存放 Id 為 15 的緩存服務器
            var nodeInfo = consistentHashing.GetNode("15");
            
            // 刪除節點測試
            consistentHashing.RemoveNode(new NodeInfo {IPAddress = "192.168.1.103"});
        }
    }
}