分布式之一致性hash

Posted pengthrree

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了分布式之一致性hash相关的知识,希望对你有一定的参考价值。

一致性Hash算法

  概念:先构造一个长度为232的整数环(这个环被称为一致性Hash环),根据节点名称的Hash值(其分布为[0, 232-1])将服务器节点放置在这个Hash环上,然后根据数据的Key值计算得到其Hash值(其分布也为[0, 232-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,232-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

个人公众号:  技术图片

 

以上是关于分布式之一致性hash的主要内容,如果未能解决你的问题,请参考以下文章

算法之一致性hash

架构实践使用 golang 实现一致性Hash算法代码

memcached 分布式 一致性hash算法demo

深入一致性哈希(Consistent Hashing)算法原理,并附100行代码实现

一致性哈希算法PHP测试片段

一致性Hash算法及使用场景