一致性hash算法

本文参考博客： https://blog.csdn.net/xp178171640/article/details/102690119

1. 一致性哈希的基本概念

一致性Hash算法也是使用取模的方法，对数据和服务器节点均取hash值，只是普通取模法是对服务器的数量进行取模，而一致性Hash算法是对 2³² 取模，一致性Hash算法将整个哈希值空间组织成一个虚拟的圆环，hash 值空间为 0 ~ 2³²-1（即哈希值是一个32位无符号整形）
定位数据访问的相应服务器：将数据key使用相同的Hash函数计算出哈希值，并确定此数据在环上的位置，从此位置沿环顺时针“行走”，第一台遇到的服务器就是其应该定位到的服务器。

2. 一致性Hash算法的容错性和可扩展性

i. 容错性

现假设Node C服务器不幸宕机，可以看到此时对象A、B、D不会受到影响，只有C对象被重定位到Node D。一般的，在一致性Hash算法中，如果一台服务器不可用，则受影响的数据仅仅是此服务器到其环空间中前一台服务器（即沿着逆时针方向行走遇到的第一台服务器）之间数据，其它不会受到影响

ii. 可扩展性

现在系统中增加一台服务器Node X，此时对象Object A、B、D不受影响，只有对象C需要重定位到新的Node X ！一般的，在一致性Hash算法中，如果增加一台服务器，则受影响的数据仅仅是新服务器到其环空间中前一台服务器（即沿着逆时针方向行走遇到的第一台服务器）之间数据，其它数据也不会受到影响

3. Hash环的数据倾斜问题

一致性Hash算法在服务节点太少时，容易因为节点分部不均匀而造成数据倾斜（被缓存的对象大部分集中缓存在某一台服务器上）问题

此时必然造成大量数据集中到Node A上，而只有极少量会定位到Node B上，从而出现hash环偏斜的情况，当hash环偏斜以后，缓存往往会极度不均衡的分布在各服务器上，如果想要均衡的将缓存分布到2台服务器上，最好能让这2台服务器尽量多的、均匀的出现在hash环上，但是，真实的服务器资源只有2台，我们怎样凭空的让它们多起来呢，我们可以将现有的物理节点通过虚拟的方法复制出来，对每一个服务节点计算多个哈希，每个计算结果位置都放置一个此服务节点，称为虚拟节点。例如上面的情况，可以为每台服务器计算三个虚拟节点，于是可以分别计算 “Node A#1”、“Node A#2”、“Node A#3”、“Node B#1”、“Node B#2”、“Node B#3”的哈希值，于是形成六个虚拟节点

数据定位算法不变，只是多了一步虚拟节点到实际节点的映射，例如定位到“Node A#1”、“Node A#2”、“Node A#3”三个虚拟节点的数据均定位到Node A上，这样就解决了服务节点少时数据倾斜的问题

4. 代码实现

i. 不带虚拟节点

public class ConsistentHashingWithoutVirtualNode {  

    //待添加入Hash环的服务器列表  
    private static String[] servers = { "192.168.0.0:111", "192.168.0.1:111", 
            "192.168.0.2:111", "192.168.0.3:111", "192.168.0.4:111" };  

    //key表示服务器的hash值，value表示服务器  
    private static SortedMap<Integer, String> sortedMap = new TreeMap<Integer, String>();  
    
    //使用FNV1_32_HASH算法计算服务器的Hash值,这里不使用重写hashCode的方法，最终效果没区别  
    private static int getHash(String str) {  
        final int p = 16777619;  
        int hash = (int) 2166136261L;  
        for (int i = 0; i < str.length(); i++)  
            hash = (hash ^ str.charAt(i)) * p;  
        hash += hash << 13;  
        hash ^= hash >> 7;  
        hash += hash << 3;  
        hash ^= hash >> 17;  
        hash += hash << 5;  

        // 如果算出来的值为负数则取其绝对值  
        if (hash < 0)  
            hash = Math.abs(hash);  
        return hash;  
    } 

    //程序初始化，将所有的服务器存入sortedMap中  
    static {  
        for (int i=0; i<servers.length; i++) {  
            int hash = getHash(servers[i]);  
            sortedMap.put(hash, servers[i]);  
        }  
    }  

    //得到应当路由到的结点  
    private static String getServer(String key) {  
        int hash = getHash(key); //得到该key的hash值  
        SortedMap<Integer, String> subMap = sortedMap.tailMap(hash); //得到大于该Hash值的所有Map    
        if(subMap.isEmpty()){  
            //如果没有比该key的hash值大的，则从第一个node开始  
            Integer i = sortedMap.firstKey();  
            //返回对应的服务器  
            return sortedMap.get(i);  
        }else{  
            //第一个Key就是顺时针过去离node最近的那个结点  
            Integer i = subMap.firstKey();  
            //返回对应的服务器  
            return subMap.get(i);  
        }  
    }  

    public static void main(String[] args) {  
        String[] keys = {"太阳", "月亮", "星星"};  
        for(int i=0; i<keys.length; i++)  
            System.out.println("[" + keys[i] + "]的hash值为" + getHash(keys[i])  
                    + ", 被路由到结点[" + getServer(keys[i]) + "]");  
    }  
} 

/* output:
[太阳]的hash值为1977106057, 被路由到结点[192.168.0.1:111]
[月亮]的hash值为1132637661, 被路由到结点[192.168.0.3:111]
[星星]的hash值为880019273, 被路由到结点[192.168.0.3:111]
*/

ii. 带虚拟节点

public class ConsistentHashingWithoutVirtualNode {  

    //待添加入Hash环的服务器列表  
    private static String[] servers = {"192.168.0.0:111", "192.168.0.1:111", "192.168.0.2:111",  
            "192.168.0.3:111", "192.168.0.4:111"};   

    //虚拟节点，key表示虚拟节点的hash值，value表示虚拟节点的名称  
    private static SortedMap<Integer, String> virtualNodes = new TreeMap<Integer, String>();  

    //虚拟节点的数目，这里写死，为了演示需要，一个真实结点对应5个虚拟节点  
    private static final int VIRTUAL_NODES = 5;  
    
    //使用FNV1_32_HASH算法计算服务器的Hash值,这里不使用重写hashCode的方法，最终效果没区别  
    private static int getHash(String str){  
        final int p = 16777619;  
        int hash = (int)2166136261L;  
        for (int i = 0; i < str.length(); i++)  
            hash = (hash ^ str.charAt(i)) * p;  
        hash += hash << 13;  
        hash ^= hash >> 7;  
        hash += hash << 3;  
        hash ^= hash >> 17;  
        hash += hash << 5;  

        // 如果算出来的值为负数则取其绝对值  
        if (hash < 0)  
            hash = Math.abs(hash);  
        return hash;  
    }

    static{  
        //再添加虚拟节点，遍历LinkedList使用foreach循环效率会比较高  
        for (String str : servers){  
            for(int i=0; i<VIRTUAL_NODES; i++){  
                String virtualNodeName = str + "&&VN" + String.valueOf(i);  
                int hash = getHash(virtualNodeName);  
                virtualNodes.put(hash, virtualNodeName);  
            }  
        }  
    }  

    //得到应当路由到的结点  
    private static String getServer(String key){  
        int hash = getHash(key);  //得到该key的hash值 
        SortedMap<Integer, String> subMap = virtualNodes.tailMap(hash);  // 得到大于该Hash值的所有Map  
        String virtualNode;  
        if(subMap.isEmpty()){  
           //如果没有比该key的hash值大的，则从第一个node开始  
           Integer i = virtualNodes.firstKey();  
           //返回对应的服务器  
           virtualNode = virtualNodes.get(i);  
        }else{  
           //第一个Key就是顺时针过去离node最近的那个结点  
           Integer i = subMap.firstKey();  
           //返回对应的服务器  
           virtualNode = subMap.get(i);  
        }  
        
        // 虚拟节点到实际节点映射关系 
        return virtualNode.substring(0, virtualNode.indexOf("&&"));  
    }  

    public static void main(String[] args){  
        String[] keys = {"太阳", "月亮", "星星"};  
        for(int i=0; i<keys.length; i++)  
            System.out.println("[" + keys[i] + "]的hash值为" +  
                    getHash(keys[i]) + ", 被路由到结点[" + getServer(keys[i]) + "]");  
    }  
}

/* output:
[太阳]的hash值为1977106057, 被路由到结点[192.168.0.2:111]
[月亮]的hash值为1132637661, 被路由到结点[192.168.0.4:111]
[星星]的hash值为880019273, 被路由到结点[192.168.0.3:111]
*/