一致性Hash算法

 一致性Hash算法

 一致性Hash算法在1997年由麻省理工学院提出的一种分布式哈希（DHT）实现算法，设计目标是为了解决因特网中的热点（Hot Spot）问题，初衷和CARP十分相似。一致性Hash修正了CARP使用的简单哈希算法带来的问题，使得分布式哈希（DHT）可以在P2P环境中真正得到应用。

 

一致性Hash算法提出了在动态变化的Cache环境中，判定哈希算法好坏的四个定义：

1、平衡性（Balance）：平衡性是指哈希的结果能够尽可能分布在所有的缓冲(Cache)中去，这样可以使得所有的缓冲空间得到利用。很多哈希算法都能够满足这一条件。

2、单调性（Monotonicity）：单调性是指如果已经有一些内容通过哈希分派到了相应的缓冲中，又有新的缓冲加入到系统中。哈希的结果应该能够保证原有已分配的内容可以被映射到原有的或者新的缓冲中去，而不会映射到旧的缓冲集合中的其他缓冲区。

3、分散性（Spread）：在分布式环境中，终端有可能看不到所有的缓冲，而只能看到其中的一部分。当终端希望通过哈希过程将内容映射到缓冲上去，由于不同终端所见的缓冲范围有可能不同，从而导致哈希的结果不一致，最终的结果是相同的内容被不同的终端映射到不同的缓冲区中。这种情况显然是应该避免的，因为它导致相同内容被存储到不同缓冲中去，降低了系统存储的效率。分散性的定义就是上述情况发生的严重程度。好的哈希算法应该能够尽量避免不一致的情况发生，也就是尽量降低分散性。

4、负载（Load）：负载问题实际上是从另一个角度看待分散性问题。既然不同的终端可能将相同的内容映射到不同的缓冲区中，那么对于一个特定的缓冲区而言，也可能被不同的用户映射到不同的内容。与分散性一样，这种情况也是应当避免的，因此好的哈希算法应能够尽量降低缓冲的负荷。

 

在分布式集群中，对机器的添加删除，或者机器故障后自动脱落集群这些操作是分布式集群管理最基本的功能。如果采用常用的hash(object)%N算法，那么在有机器添加或者删除后，很多原有的数据就无法找到了，这样严重的违反了单调性原则。

解释使用hash(object)%N，其中N是指N个cache服务器/N个节点为啥不行：

 

如果N个cache服务器中编号为a的服务器故障了，需要把a从服务器群中移除，这个时候cache服务器的数量就变成了N-1台，那么所有对象(object)映射到cache服务器的计算公式就变成了hash(object)%N-1，对，影响到了所有的对象与cache服务器的映射关系，类似，由于访问加重，需要添加cache服务器，这时候cache服务器是N+1台，映射公式就变成了hash(object)%N+1,这就意味着几乎所有的cache都失效了，对于服务器而言，这是一场灾难，所有访问都会直接冲向后台服务器。

 

接下来主要讲解一下一致性哈希算法是如何设计的：核心思想是节点的缓存范围由固定式变为可变范围式。

上面说过hash结点的边界是由总边界分为N段来确定的，思路换一下，把它想象为一个环形，这是一个0~（2^32）-1的数字空间。如下图

 

下一个问题是如何确定每个节点的缓存边界；

简单而言将object1、object2、object3、object4四个对象Hash并散列到环上。

如下图：

Hash(object1) = key1；

Hash(object2) = key2；

Hash(object3) = key3；

Hash(object4) = key4；

 

 

在缓存时，对缓存内容标识进行hash，结果值位于节点顺时针方向的归属于本节点。

假设现在有NODE1，NODE2，NODE3三台机器，通过Hash算法得到对应的KEY值，映射到环中，其示意图如下：

Hash(NODE1) = KEY1;

Hash(NODE2) = KEY2;

Hash(NODE3) = KEY3;

 

通过上图可以看出对象与机器处于同一哈希空间中，这样按顺时针转动object1存储到了NODE1中，object3存储到了NODE2中，object2、object4存储到了NODE3中。在这样的部署环境中，hash环是不会变更的，因此，通过算出对象的hash值就能快速的定位到对应的机器中，这样就能找到对象真正的存储位置了。

 

机器的删除与添加

普通hash求余算法最为不妥的地方就是在有机器的添加或者删除之后会照成大量的对象存储位置失效，这样就大大的不满足单调性了。下面来分析一下一致性哈希算法是如何处理的。

1. 节点（机器）的删除

以上面的分布为例，如果NODE2出现故障被删除了，那么按照顺时针迁移的方法，object3将会被迁移到NODE3中，这样仅仅是object3的映射位置发生了变化，其它的对象没有任何的改动。如下图：

 

 

 

2. 节点（机器）的添加 

如果往集群中添加一个新的节点NODE4，通过对应的哈希算法得到KEY4，并映射到环中，如下图：

 

通过按顺时针迁移的规则，那么object2被迁移到了NODE4中，其它对象还保持这原有的存储位置。数据的迁移最少。

 

 

总结：一致性哈希算法在保持了单调性的同时，还使数据的迁移达到最少。

 

如果服务器比较少的情况下，一般都会引入虚拟节点的概念。

虚拟节点

如上面只部署了NODE1和NODE3的情况（NODE2被删除的图），object1存储到了NODE1中，而object2、object3、object4都存储到了NODE3中，这样就照成了非常不平衡的状态。在一致性哈希算法中，为了尽可能的满足平衡性，其引入了虚拟节点。

 “虚拟节点”（ virtual node ）是实际节点（机器）在 hash 空间的复制品（ replica ），一实际个节点（机器）对应了若干个“虚拟节点”，这个对应个数也成为“复制个数”，“虚拟节点”在 hash 空间中以hash值排列。

主要思想：

把机器按照某种hash算法（比如MD5）计算得到机器的hashcode值。

对于存储的数据，根据数据的key，使用与机器相同的hash算法获取到相应的hashcode值，然后将key写入到顺时针最近的机器。 

可以是hashcode(key) <= hashcode(machine)的机器。

当有新机器加入时，只需要把新加入机器影响到的数据进行重新分配；当删除机器时，只需要把被删除机器的数据重新分配一下，这样可以减小数据的迁移代价。

为了维持平衡性，防止雪崩效应，使用虚拟节点代替真实机器，一个真实机器对应多个虚拟节点，这样可以保证数据的分布均衡

 

# 一致性hash

 

import hashlib

 

class ConHash(object):

    def __init__(self, nodes=None, n_number=4):

        """

 

        :param nodes: 所有的节点

        :param n_number: 一个节点对应多少个虚拟节点

        """

        self._n_number = n_number

        self._node_dict = dict()

        self._sort_list = []

        if nodes:

            for node in nodes:

                self.add_node(node)

 

    def add_node(self, node):

        """

        添加node，首先要根据虚拟节点数目，创建所有的虚拟节点

        并关联所有的节点

        还需要将虚拟节点的hash值放到排序队列中

        添加了节点后，需要保持虚拟节点hash的顺序

        :param node:

        :return:

        """

        for i in range(self._n_number):

            node_str = "%s#%s" % (node, i)

            key = self._gen_key(node_str)

            self._node_dict[key] = node

            self._sort_list.append(key)

        self._sort_list.sort()

 

    def remove_node(self, node):

        """

        delete a node from class

        :param node:

        :return:

        """

        for i in range(self._n_number):

            node_str = "%s#%s" %(node, i)

            key = self._gen_key(node_str)

            del self._node_dict[key]

 

    def get_node(self, key_str):

        """

        返回字符串所对应的node<

        先求出字符串的hash值，然后找到第一个小于等于它的虚拟节点

        如果该值大于所有的节点，返回第一个节点

        :param key_str:

        :return:

        """

        if self._sort_list:

            key = self._gen_key(key_str)

            for node_key in self._sort_list:

                if key <= node_key:

                    return self._node_dict[node_key]

                else:

                    return self._node_dict[self._sort_list[0]]

        else:

            return None

 

    @staticmethod

    def _gen_key(key_str):

        """

        返回key的hash值，当前采用md5

        :param key_str:

        :return:

        """

        md5_str = hashlib.md5(key_str.encode(encoding='utf-8')).hexdigest()

        return md5_str

 

def test_func():

    ring = ConHash(["192.168.1.1","192.168.1.2","192.168.1.3","192.168.1.4"])

    for x in range(15):

        st = "DV" + str(x).zfill(3)

        print(st)

        print(ring.get_node(st))

 

 

test_func()

 

转载于:https://www.cnblogs.com/wodeboke-y/p/11407757.html