分布式之一致性hash

Posted 2020-12-14 pengthrree

一致性Hash算法

　　概念：先构造一个长度为2³²的整数环（这个环被称为一致性Hash环），根据节点名称的Hash值（其分布为[0, 2³²-1]）将服务器节点放置在这个Hash环上，然后根据数据的Key值计算得到其Hash值（其分布也为[0, 2³²-1]），接着在Hash环上顺时针查找距离这个Key值的Hash值最近的服务器节点，完成Key到服务器的映射查找。

这种算法解决了普通余数Hash算法伸缩性差的问题，可以保证在上线、下线服务器的情况下尽量有多的请求命中原来路由到的服务器。

当然，万事不可能十全十美，一致性Hash算法比普通的余数Hash算法更具有伸缩性，（普通的余数hash算法增加或者减少机器的时候容易造成大量缓存失效从而倒置雪崩）但是同时其算法实现也更为复杂，本文就来研究一下，如何利用Java代码实现一致性Hash算法。在开始之前，先对一致性Hash算法中的几个核心问题进行一些探究。

 

 

 

一致性hash算法的线上应用

 　　首先我们来看下String的hashCode()的方法计算出来的hash值代码如下：

/**
 * @Classname Test
 * @Description TODO
 * @Date 2020/7/3 4:48 PM
 * @Author by pengasan
 */
public class Test {
    public static void main(String[] args) {
        System.out.println("192.168.1.1:111的哈希值：" + "192.168.1.1:111".hashCode());
        System.out.println("192.168.1.2:111的哈希值：" + "192.168.1.2:111".hashCode());
        System.out.println("192.168.1.3:111的哈希值：" + "192.168.1.3:111".hashCode());
        System.out.println("192.168.1.4:111的哈希值：" + "192.168.1.4:111".hashCode());
    }
}


//为了更有代表性我们做了10000个ip的hash值的运算

/**
 * @Classname Test
 * @Description TODO
 * @Date 2020/7/3 4:48 PM
 * @Author by pengasan
 */
public class Test {
    public static void main(String[] args) {
        for (int i= 0;i<10000;i++) {
            String s = "192.168.1." + i + ":111";
            System.out.println("192.168.1."+i+":111的哈希值：" + s.hashCode());
        }
    }
}

　　我们在做集群的时候，集群点的IP以这种连续的形式存在是很正常的。看一下运行结果为：

192.168.1.1:111的哈希值：116687404
192.168.1.2:111的哈希值：117610925
192.168.1.3:111的哈希值：118534446
192.168.1.4:111的哈希值：119457967


//10000个hash值的结果大致如下：

192.168.1.851:111的哈希值：-2052839345
192.168.1.852:111的哈希值：-2051915824
192.168.1.853:111的哈希值：-2050992303
192.168.1.854:111的哈希值：-2050068782
192.168.1.855:111的哈希值：-2049145261
192.168.1.856:111的哈希值：-2048221740
192.168.1.857:111的哈希值：-2047298219
192.168.1.858:111的哈希值：-2046374698
192.168.1.859:111的哈希值：-2045451177

192.168.1.9965:111的哈希值：1923143826
192.168.1.9966:111的哈希值：1924067347
192.168.1.9967:111的哈希值：1924990868
192.168.1.9968:111的哈希值：1925914389
192.168.1.9969:111的哈希值：1926837910
192.168.1.9970:111的哈希值：1947155372
192.168.1.9971:111的哈希值：1948078893
192.168.1.9972:111的哈希值：1949002414
192.168.1.9973:111的哈希值：1949925935
192.168.1.9974:111的哈希值：1950849456
192.168.1.9975:111的哈希值：1951772977
192.168.1.9976:111的哈希值：1952696498
192.168.1.9977:111的哈希值：1953620019
192.168.1.9978:111的哈希值：1954543540
192.168.1.9979:111的哈希值：1955467061
192.168.1.9980:111的哈希值：1975784523
192.168.1.9981:111的哈希值：1976708044
192.168.1.9982:111的哈希值：1977631565
192.168.1.9983:111的哈希值：1978555086
192.168.1.9984:111的哈希值：1979478607
192.168.1.9985:111的哈希值：1980402128
192.168.1.9986:111的哈希值：1981325649
192.168.1.9987:111的哈希值：1982249170
192.168.1.9988:111的哈希值：1983172691
192.168.1.9989:111的哈希值：1984096212
192.168.1.9990:111的哈希值：2004413674
192.168.1.9991:111的哈希值：2005337195
192.168.1.9992:111的哈希值：2006260716
192.168.1.9993:111的哈希值：2007184237
192.168.1.9994:111的哈希值：2008107758
192.168.1.9995:111的哈希值：2009031279
192.168.1.9996:111的哈希值：2009954800
192.168.1.9997:111的哈希值：2010878321
192.168.1.9998:111的哈希值：2011801842
192.168.1.9999:111的哈希值：2012725363

hash值的区间基本大致是-2052839345--2012725363这样的区间，并且有负数的存在，当然我们可以通过取绝对值的方法规避负数。最重要的是一致性hash的区间是[0,2³²-1]中有4294967296个数字，我们的hashcode方法的hash值远远小于一致性hash区间这样会倒置数据严重的不匀均可能有的节点会存在百分之90的数据。综上，String重写的hashCode()方法在一致性Hash算法中没有任何实用价值，得找个算法重新计算HashCode。这种重新计算Hash值的算法有很多，比如CRC32_HASH、FNV1_32_HASH、KETAMA_HASH等，其中KETAMA_HASH是默认的MemCache推荐的一致性Hash算法，用别的Hash算法也可以，比如FNV1_32_HASH算法的计算效率就会高一些。

 

一致性Hash算法实现版本1：不带虚拟节点

使用一致性Hash算法，尽管增强了系统的伸缩性，但是也有可能导致负载分布不均匀，解决办法就是使用虚拟节点代替真实节点，第一个代码版本，先来个简单的，不带虚拟节点。想象一下一个环上只有三点节点，很容就分布的不均匀。

下面来看一下不带虚拟节点的一致性Hash算法的Java代码实现：

/**
 * @Classname Hash
 * @Description 不带虚拟节点的一致性hash算法实现
 * @Date 2020/7/3 2:40 PM
 * @Author by pengasan
 */
public class Hash {
    //待添加入Hash环的服务器列表
    private static String[] servers = { "192.168.0.0:111", "192.168.0.1:111",
            "192.168.0.2:111"};


    //key表示服务器的hash值，value表示服务器
    private static SortedMap<Integer, String> sortedMap = new TreeMap<Integer, String>();

    //程序初始化，将所有的服务器放入sortedMap中
    static {
        for (int i=0; i<servers.length; i++) {
            //int hash = Objects.hash(servers[i]);
            int hash = getHash(servers[i]);
            System.out.println("[" + servers[i] + "]加入集合中, 其Hash值为" + hash);
            sortedMap.put(hash, servers[i]);
        }
        System.out.println();
    }

    //得到应当路由到的结点
    private static String getServer(String key) {
        //得到该key的hash值
        //int hash = Objects.hash(key);
        int hash = getHash(key);
        //得到大于该Hash值的所有Map
        SortedMap<Integer, String> subMap = sortedMap.tailMap(hash);
        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);
        }
    }


    //使用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;
    }


    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]) + "]");
        }
    }
}

运行结果如下：

[192.168.0.0:111]加入集合中, 其Hash值为1767802393
[192.168.0.1:111]加入集合中, 其Hash值为406441873
[192.168.0.2:111]加入集合中, 其Hash值为800212117

[太阳]的hash值为1161471302, 被路由到结点[192.168.0.0:111]
[月亮]的hash值为1278882846, 被路由到结点[192.168.0.0:111]
[星星]的hash值为303545150, 被路由到结点[192.168.0.1:111]

　看到经过FNV1_32_HASH算法重新计算过后的Hash值，就比原来String的hashCode()方法好多了。从运行结果来看，也没有问题，三个点路由到的都是顺时针离他们Hash值最近的那台服务器上。最重要的是这样的一致性算法可以解决扩展性差的问题，但是这样的一致性算法是不能在生产环境使用的。因为这样的算法是负载不均匀的。

 

使用虚拟节点来改善一致性Hash算法

 　

比如说有Hash环上有A、B、C三个服务器节点，分别有100个请求会被路由到相应服务器上。现在在A与B之间增加了一个节点D，这导致了原来会路由到B上的部分节点被路由到了D上，这样A、C上被路由到的请求明显多于B、D上的，原来三个服务器节点上均衡的负载被打破了。某种程度上来说，这失去了负载均衡的意义，因为负载均衡的目的本身就是为了使得目标服务器均分所有的请求。

解决这个问题的办法是引入虚拟节点，其工作原理是：将一个物理节点拆分为多个虚拟节点，并且同一个物理节点的虚拟节点尽量均匀分布在Hash环上。采取这样的方式，就可以有效地解决增加或减少节点时候的负载不均衡的问题。

想象一下我们把一个节点虚拟化成200个节点使他更加的分散在hash环上这样我们就能解决负载不均衡的问题。

在理解了使用虚拟节点来改善一致性Hash算法的理论基础之后，就可以尝试开发代码了。编程方面需要考虑的问题是：

• 一个真实结点如何对应成为多个虚拟节点？
• 虚拟节点找到后如何还原为真实结点？

至于一个真实结点对应分成多少个虚拟结点的问题，经过大量的测试一般是150-200个虚拟结点会达到较好的效果，具体的实现还需要根据真实节点去测试。那么虚拟节点可以为真实节点+后缀名的方式实现那么还原也比较容易。

下面代码实现如下：

/**
 * @Classname VnodeHash
 * @Description 带虚拟节点的一致性hash实现
 * @Date 2020/7/3 2:40 PM
 * @Author by pengasan
 */
public class VnodeHash {
    //待添加入Hash环的服务器列表
    private static String[] servers = {"192.168.0.0:111", "192.168.0.1:111", "192.168.0.2:111"};

    //真实结点列表,考虑到服务器上线、下线的场景，即添加、删除的场景会比较频繁，这里使用LinkedList会更好
    private static List<String> realNodes = new LinkedList<String>();


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

    //虚拟节点的数目，这里写死，为了演示需要，一个真实结点对应200个虚拟节点
    private static final int VIRTUAL_NODES = 200;


    static{
        //先把原始的服务器添加到真实结点列表中
        for(int i=0; i<servers.length; i++)
            realNodes.add(servers[i]);

        //再添加虚拟节点，遍历LinkedList使用foreach循环效率会比较高
        for (String str : realNodes){
            for(int i=0; i<VIRTUAL_NODES; i++){
                String virtualNodeName = str + "#node" + String.valueOf(i);
                int hash = getHash(virtualNodeName);
                System.out.println("虚拟节点[" + virtualNodeName + "]被添加, hash值为" + hash);
                virtualNodes.put(hash, virtualNodeName);
            }
        }
        System.out.println();
    }
    //使用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;
    }

    //得到应当路由到的结点
    private static String  getServer(String key){
        //得到该key的hash值
        int hash = getHash(key);
        // 得到大于该Hash值的所有Map
        SortedMap<Integer, String> subMap = virtualNodes.tailMap(hash);
        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);
        }
        //virtualNode虚拟节点名称要截取一下
        if(StringUtils.isNotBlank(virtualNode)){
            return virtualNode.substring(0, virtualNode.indexOf("#node"));
        }
        return null;
    }
    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]) + "]");
    }


}

运行代码可以查找到虚拟节点的hash值，求出来数据的key的hash值来找到对应的节点。这样我们就能解决了扩展差和负载差的问题。

 码云：https://gitee.com/pengasan/study.git

Info：https://www.infoq.cn/profile/1593076/publish

个人公众号：