一致性哈希算法与Java实现

爱被打了一巴掌 2022-05-23 11:48 182阅读 0赞

一致性哈希算法与Java实现

========================================================

一致性哈希算法是分布式系统中常用的算法。比如，一个分布式的存储系统，要将数据存储到具体的节点上，  
如果采用普通的hash方法，将数据映射到具体的节点上，如key%N，key是数据的key，N是机器节点数，  
如果有一个机器加入或退出这个集群，则所有的数据映射都无效了。  
  
一致性哈希算法解决了普通余数Hash算法伸缩性差的问题，可以保证在上线、下线服务器的情况下尽量有多的请求命中原来路由到的服务器。

一、一致性哈希算法

1、原理

(1)环形Hash空间  
  
按照常用的hash算法来将对应的key哈希到一个具有2^32次方个桶的空间中，即0~(2^32)-1的数字空间中。

现在我们可以将这些数字头尾相连，想象成一个闭合的环形。如下图  
![Center][]  
(2)把数据通过一定的hash算法处理后映射到环上  
  
现在我们将object1、object2、object3、object4四个对象通过特定的Hash函数计算出对应的key值，然后散列到Hash环上。如下图：  
Hash(object1) = key1；  
Hash(object2) = key2；  
Hash(object3) = key3；  
Hash(object4) = key4；  
![Center 1][]  
  
(3)将机器通过hash算法映射到环上  
  
在采用一致性哈希算法的分布式集群中将新的机器加入，其原理是通过使用与对象存储一样的Hash算法将机器也映射到环中

（一般情况下对机器的hash计算是采用机器的IP或者机器唯一的别名作为输入值），然后以顺时针的方向计算，将所有对象存储到离自己最近的机器中。  
  
假设现在有NODE1，NODE2，NODE3三台机器，通过Hash算法得到对应的KEY值，映射到环中，其示意图如下：  
Hash(NODE1) = KEY1;  
Hash(NODE2) = KEY2;  
Hash(NODE3) = KEY3;  
  
![Center 2][]  
通过上图可以看出对象与机器处于同一哈希空间中，这样按顺时针转动object1存储到了NODE1中，object3存储到了NODE2中，object2、object4存储到了NODE3中。

在这样的部署环境中，hash环是不会变更的，因此，通过算出对象的hash值就能快速的定位到对应的机器中，这样就能找到对象真正的存储位置了。  
  
2、机器的删除与添加  
普通hash求余算法最为不妥的地方就是在有机器的添加或者删除之后会造成大量的对象存储位置失效。下面来分析一下一致性哈希算法是如何处理的。  
  
(1)节点（机器）的删除  
以上面的分布为例，如果NODE2出现故障被删除了，那么按照顺时针迁移的方法，object3将会被迁移到NODE3中，这样仅仅是object3的映射位置发生了变化，其它的对象没有任何的改动。如下图：  
![Center 3][]  
  
(2)节点（机器）的添加   
如果往集群中添加一个新的节点NODE4，通过对应的哈希算法得到KEY4，并映射到环中，如下图：  
![Center 4][]  
  
通过按顺时针迁移的规则，那么object2被迁移到了NODE4中，其它对象还保持着原有的存储位置。  
通过对节点的添加和删除的分析，一致性哈希算法在保持了单调性的同时，还是数据的迁移达到了最小，这样的算法对分布式集群来说是非常合适的，避免了大量数据迁移，减小了服务器的的压力。  
  
3、平衡性--虚拟节点  
  
根据上面的图解分析，一致性哈希算法满足了单调性和负载均衡的特性以及一般hash算法的分散性，但这还并不能当做其被广泛应用的原由，

因为还缺少了平衡性。下面将分析一致性哈希算法是如何满足平衡性的。  
  
hash算法是不保证平衡的，如上面只部署了NODE1和NODE3的情况（NODE2被删除的图），object1存储到了NODE1中，而object2、object3、object4都存储到了NODE3中，这样就造成了非常不平衡的状态。在一致性哈希算法中，为了尽可能的满足平衡性，其引入了虚拟节点。  
  
——“虚拟节点”（ virtual node ）是实际节点（机器）在 hash 空间的复制品（ replica ），一个实际节点（机器）对应了若干个“虚拟节点”，这个对应个数也成为“复制个数”，“虚拟节点”在 hash 空间中以hash值排列。  
  
以上面只部署了NODE1和NODE3的情况（NODE2被删除的图）为例，之前的对象在机器上的分布很不均衡，现在我们以2个副本（复制个数）为例，这样整个hash环中就存在了4个虚拟节点，最后对象映射的关系图如下：  
  
![Center 5][]  
根据上图可知对象的映射关系：object1->NODE1-1，object2->NODE1-2，object3->NODE3-2，object4->NODE3-1。通过虚拟节点的引入，对象的分布就比较均衡了。那么在实际操作中，正真的对象查询是如何工作的呢？对象从hash到虚拟节点到实际节点的转换如下图：  
![Center 6][]  
  
“虚拟节点”的hash计算可以采用对应节点的IP地址加数字后缀的方式。例如假设NODE1的IP地址为192.168.1.100。引入“虚拟节点”前，计算 cache A 的 hash 值：  
Hash(“192.168.1.100”);  
引入“虚拟节点”后，计算“虚拟节”点NODE1-1和NODE1-2的hash值：  
Hash(“192.168.1.100\#1”); // NODE1-1  
Hash(“192.168.1.100\#2”); // NODE1-2

二、一致性hash算法的Java实现

1、不带虚拟节点的

\[java\]  [view plain][]   [copy][view plain]

1.  **package** hash;  
2.    
3.  **import** java.util.SortedMap;  
4.  **import** java.util.TreeMap;  
5.    
6.  /\*\* 
7.   \* 不带虚拟节点的一致性Hash算法 
8.   \*/  
9.  **public** **class** ConsistentHashingWithoutVirtualNode \{  
10.   
11.     //待添加入Hash环的服务器列表  
12.     **private** **static** String\[\] servers = \{ "192.168.0.0:111", "192.168.0.1:111",  
13.             "192.168.0.2:111", "192.168.0.3:111", "192.168.0.4:111" \};  
14.   
15.     //key表示服务器的hash值，value表示服务器  
16.     **private** **static** SortedMap<Integer, String> sortedMap = **new** TreeMap<Integer, String>();  
17.   
18.     //程序初始化，将所有的服务器放入sortedMap中  
19.     **static** \{  
20.         **for** (**int** i=0; i<servers.length; i++) \{  
21.             **int** hash = getHash(servers\[i\]);  
22.             System.out.println("\[" + servers\[i\] + "\]加入集合中, 其Hash值为" + hash);  
23.             sortedMap.put(hash, servers\[i\]);  
24.         \}  
25.         System.out.println();  
26.     \}  
27.   
28.     //得到应当路由到的结点  
29.     **private** **static** String getServer(String key) \{  
30.         //得到该key的hash值  
31.         **int** hash = getHash(key);  
32.         //得到大于该Hash值的所有Map  
33.         SortedMap<Integer, String> subMap = sortedMap.tailMap(hash);  
34.         **if**(subMap.isEmpty())\{  
35.             //如果没有比该key的hash值大的，则从第一个node开始  
36.             Integer i = sortedMap.firstKey();  
37.             //返回对应的服务器  
38.             **return** sortedMap.get(i);  
39.         \}**else**\{  
40.             //第一个Key就是顺时针过去离node最近的那个结点  
41.             Integer i = subMap.firstKey();  
42.             //返回对应的服务器  
43.             **return** subMap.get(i);  
44.         \}  
45.     \}  
46.       
47.     //使用FNV1\_32\_HASH算法计算服务器的Hash值,这里不使用重写hashCode的方法，最终效果没区别  
48.     **private** **static** **int** getHash(String str) \{  
49.         **final** **int** p = 16777619;  
50.         **int** hash = (**int**) 2166136261L;  
51.         **for** (**int** i = 0; i < str.length(); i++)  
52.             hash = (hash ^ str.charAt(i)) \* p;  
53.         hash += hash << 13;  
54.         hash ^= hash >> 7;  
55.         hash += hash << 3;  
56.         hash ^= hash >> 17;  
57.         hash += hash << 5;  
58.   
59.         // 如果算出来的值为负数则取其绝对值  
60.         **if** (hash < 0)  
61.             hash = Math.abs(hash);  
62.         **return** hash;  
63.         \}  
64.   
65.     **public** **static** **void** main(String\[\] args) \{  
66.         String\[\] keys = \{ "太阳", "月亮", "星星"\};  
67.         **for**(**int** i=0; i<keys.length; i++)  
68.             System.out.println("\[" + keys\[i\] + "\]的hash值为" + getHash(keys\[i\])  
69.                     + ", 被路由到结点\[" + getServer(keys\[i\]) + "\]");  
70.     \}  
71. \}

执行结果：  
\[192.168.0.0:111\]加入集合中, 其Hash值为575774686  
\[192.168.0.1:111\]加入集合中, 其Hash值为8518713  
\[192.168.0.2:111\]加入集合中, 其Hash值为1361847097  
\[192.168.0.3:111\]加入集合中, 其Hash值为1171828661  
\[192.168.0.4:111\]加入集合中, 其Hash值为1764547046  
  
\[太阳\]的hash值为1977106057, 被路由到结点\[192.168.0.1:111\]  
\[月亮\]的hash值为1132637661, 被路由到结点\[192.168.0.3:111\]  
\[星星\]的hash值为880019273, 被路由到结点\[192.168.0.3:111\]

2、带虚拟节点的

\[java\]  [view plain][]   [copy][view plain]

1.  **package** hash;  
2.    
3.  **import** java.util.LinkedList;  
4.  **import** java.util.List;  
5.  **import** java.util.SortedMap;  
6.  **import** java.util.TreeMap;  
7.    
8.  **import** org.apache.commons.lang.StringUtils;  
9.    
10. /\*\* 
11.   \* 带虚拟节点的一致性Hash算法 
12.   \*/  
13.  **public** **class** ConsistentHashingWithoutVirtualNode \{  
14.   
15.      //待添加入Hash环的服务器列表  
16.      **private** **static** String\[\] servers = \{ "192.168.0.0:111", "192.168.0.1:111", "192.168.0.2:111",  
17.              "192.168.0.3:111", "192.168.0.4:111"\};  
18.        
19.      //真实结点列表,考虑到服务器上线、下线的场景，即添加、删除的场景会比较频繁，这里使用LinkedList会更好  
20.      **private** **static** List<String> realNodes = **new** LinkedList<String>();  
21.        
22.      //虚拟节点，key表示虚拟节点的hash值，value表示虚拟节点的名称  
23.      **private** **static** SortedMap<Integer, String> virtualNodes = **new** TreeMap<Integer, String>();  
24.                
25.      //虚拟节点的数目，这里写死，为了演示需要，一个真实结点对应5个虚拟节点  
26.      **private** **static** **final** **int** VIRTUAL\_NODES = 5;  
27.        
28.      **static**\{  
29.          //先把原始的服务器添加到真实结点列表中  
30.          **for**(**int** i=0; i<servers.length; i++)  
31.              realNodes.add(servers\[i\]);  
32.            
33.          //再添加虚拟节点，遍历LinkedList使用foreach循环效率会比较高  
34.          **for** (String str : realNodes)\{  
35.              **for**(**int** i=0; i<VIRTUAL\_NODES; i++)\{  
36.                  String virtualNodeName = str + "&&VN" + String.valueOf(i);  
37.                  **int** hash = getHash(virtualNodeName);  
38.                  System.out.println("虚拟节点\[" + virtualNodeName + "\]被添加, hash值为" + hash);  
39.                  virtualNodes.put(hash, virtualNodeName);  
40.              \}  
41.          \}  
42.          System.out.println();  
43.      \}  
44.        
45.      //使用FNV1\_32\_HASH算法计算服务器的Hash值,这里不使用重写hashCode的方法，最终效果没区别  
46.      **private** **static** **int** getHash(String str)\{  
47.          **final** **int** p = 16777619;  
48.          **int** hash = (**int**)2166136261L;  
49.          **for** (**int** i = 0; i < str.length(); i++)  
50.              hash = (hash ^ str.charAt(i)) \* p;  
51.          hash += hash << 13;  
52.          hash ^= hash >> 7;  
53.          hash += hash << 3;  
54.          hash ^= hash >> 17;  
55.          hash += hash << 5;  
56.            
57.          // 如果算出来的值为负数则取其绝对值  
58.          **if** (hash < 0)  
59.              hash = Math.abs(hash);  
60.          **return** hash;  
61.      \}  
62.        
63.      //得到应当路由到的结点  
64.      **private** **static** String getServer(String key)\{  
65.         //得到该key的hash值  
66.          **int** hash = getHash(key);  
67.          // 得到大于该Hash值的所有Map  
68.          SortedMap<Integer, String> subMap = virtualNodes.tailMap(hash);  
69.          String virtualNode;  
70.          **if**(subMap.isEmpty())\{  
71.             //如果没有比该key的hash值大的，则从第一个node开始  
72.             Integer i = virtualNodes.firstKey();  
73.             //返回对应的服务器  
74.             virtualNode = virtualNodes.get(i);  
75.          \}**else**\{  
76.             //第一个Key就是顺时针过去离node最近的那个结点  
77.             Integer i = subMap.firstKey();  
78.             //返回对应的服务器  
79.             virtualNode = subMap.get(i);  
80.          \}  
81.          //virtualNode虚拟节点名称要截取一下  
82.          **if**(StringUtils.isNotBlank(virtualNode))\{  
83.              **return** virtualNode.substring(0, virtualNode.indexOf("&&"));  
84.          \}  
85.          **return** **null**;  
86.      \}  
87.        
88.      **public** **static** **void** main(String\[\] args)\{  
89.          String\[\] keys = \{ "太阳", "月亮", "星星"\};  
90.          **for**(**int** i=0; i<keys.length; i++)  
91.              System.out.println("\[" + keys\[i\] + "\]的hash值为" +  
92.                      getHash(keys\[i\]) + ", 被路由到结点\[" + getServer(keys\[i\]) + "\]");  
93.      \}  
94.  \}

执行结果：  
虚拟节点\[192.168.0.0:111&&VN0\]被添加, hash值为1686427075  
虚拟节点\[192.168.0.0:111&&VN1\]被添加, hash值为354859081  
虚拟节点\[192.168.0.0:111&&VN2\]被添加, hash值为1306497370  
虚拟节点\[192.168.0.0:111&&VN3\]被添加, hash值为817889914  
虚拟节点\[192.168.0.0:111&&VN4\]被添加, hash值为396663629  
虚拟节点\[192.168.0.1:111&&VN0\]被添加, hash值为1032739288  
虚拟节点\[192.168.0.1:111&&VN1\]被添加, hash值为707592309  
虚拟节点\[192.168.0.1:111&&VN2\]被添加, hash值为302114528  
虚拟节点\[192.168.0.1:111&&VN3\]被添加, hash值为36526861  
虚拟节点\[192.168.0.1:111&&VN4\]被添加, hash值为848442551  
虚拟节点\[192.168.0.2:111&&VN0\]被添加, hash值为1452694222  
虚拟节点\[192.168.0.2:111&&VN1\]被添加, hash值为2023612840  
虚拟节点\[192.168.0.2:111&&VN2\]被添加, hash值为697907480  
虚拟节点\[192.168.0.2:111&&VN3\]被添加, hash值为790847074  
虚拟节点\[192.168.0.2:111&&VN4\]被添加, hash值为2010506136  
虚拟节点\[192.168.0.3:111&&VN0\]被添加, hash值为891084251  
虚拟节点\[192.168.0.3:111&&VN1\]被添加, hash值为1725031739  
虚拟节点\[192.168.0.3:111&&VN2\]被添加, hash值为1127720370  
虚拟节点\[192.168.0.3:111&&VN3\]被添加, hash值为676720500  
虚拟节点\[192.168.0.3:111&&VN4\]被添加, hash值为2050578780  
虚拟节点\[192.168.0.4:111&&VN0\]被添加, hash值为586921010  
虚拟节点\[192.168.0.4:111&&VN1\]被添加, hash值为184078390  
虚拟节点\[192.168.0.4:111&&VN2\]被添加, hash值为1331645117  
虚拟节点\[192.168.0.4:111&&VN3\]被添加, hash值为918790803  
虚拟节点\[192.168.0.4:111&&VN4\]被添加, hash值为1232193678  
  
\[太阳\]的hash值为1977106057, 被路由到结点\[192.168.0.2:111\]  
\[月亮\]的hash值为1132637661, 被路由到结点\[192.168.0.4:111\]  
\[星星\]的hash值为880019273, 被路由到结点\[192.168.0.3:111\]

原文：

[http://blog.csdn.net/cywosp/article/details/23397179/ ][http_blog.csdn.net_cywosp_article_details_23397179]   一致性哈希算法

[http://www.open-open.com/lib/view/open1455374048042.html][http_www.open-open.com_lib_view_open1455374048042.html]  一致性哈希算法的Java实现

[Center]: /images/20220523/09def09990d444cbb2aa7883d1f3cf23.png
[Center 1]: /images/20220523/cd8ed41127a14fa0befb7d9708f921fd.png
[Center 2]: /images/20220523/20d6da4ab29e4cbbb95c87836248994b.png
[Center 3]: /images/20220523/f8a6d514fe1b4b1495e49c800b8a9ffe.png
[Center 4]: /images/20220523/8ca1c11ee236464d8d355228127fa3a0.png
[Center 5]: /images/20220523/0a82caddeb5140ab9d16ae9f3680da65.png
[Center 6]: /images/20220523/742b0635fff945bea9003951adfb9c4d.png
[view plain]: https://blog.csdn.net/u010558660/article/details/52767218#
[http_blog.csdn.net_cywosp_article_details_23397179]: http://blog.csdn.net/cywosp/article/details/23397179/
[http_www.open-open.com_lib_view_open1455374048042.html]: http://www.open-open.com/lib/view/open1455374048042.html