前言
一致性哈希算法在分布式系统的应用中是十分广泛的。常见的应用场景是分布式缓存。它主要解决了哈希取模算法在分布式系统中存在的动态伸缩等问题。
哈希取模算法的局限性
在分布式缓存集群中，当新增加缓存服务器或其中一台挂掉后，由路由算法发生改变，导致大量的缓存数据不能命中。从而造成数据库面临巨大压力而崩溃，可能导致整个系统崩溃。
一致性哈希算法原理
一致性哈希算法通过一个叫作一致性哈希环的数据结构实现。这个环的起点是，终点是
，并且起点和终点相连接，故这个环的整数分布范围是
。
将服务器节点和key放到哈希环上
我们将服务器节点和key的hash值放置到哈希环上，如下图：
服务器节点分别是NODE0、NODE1、NODE2。key分别代表key1 ~ key8。
将key和服务器节点都放置到同一个哈希环后，在哈希环上顺时针查找距离这个 key 的 hash 值最近的机器，即是这个key所属的机器。
key1、key8在节点NODE0上；key2、key5在节点NODE1上；key3、key4、key6在节点NODE2上。
增加服务器（扩容）
由于业务需要，如缓存集群压力过大，我们需要增加一台服务器（NODE3）。经过hash函数计算，NODE3节点落在NODE1和NODE2之间。如下图：
对上述情况，只有NODE1和NODE2节点之间的key需要重新分配。key4没有变，还在NODE2节点。只是key3、key6重新分配新的节点NODE3上。我们发现，一致性哈希算法只需要很少部分key需要重新分配。而哈希取模方式则大部分缓存会失效。
减少服务器（缩容）
由于某个服务器出现故障导致下线，如NODE3下线，这时原本key3、key6存储在NODE3上，需要重新被分配至NODE2节点上，其它key不受此影响。
服务器节点分布不均匀
- 如果服务器节点不是均匀的分布在哈希环上，那么有可能造成服务节点负载压力不均衡。
- 当新增加一台服务器时，节点NODE3只是分担了节点NODE2的压力，造成服务器压力不均摊。显然这个结果不是我们期望的。
针对这个问题，我们可以通过引入虚拟节点来解决负载不均衡的问题。即将每台物理服务器虚拟为一组虚拟服务器，将虚拟服务器放置到哈希环上，如果要确定key所在的服务器，需先确定key所在的虚拟服务器，再由虚拟服务器确定物理服务器。
基于虚拟节点的一致性哈希
一台物理服务器，虚拟成若干个虚拟节点，随机分布在环上，压力近似均衡分摊。如有三台物理服务器，每台物理服务器虚拟出150个虚拟节点，随机分配在Hash环上的150个位置上。最后可使三台物理服务器近似均摊压力。当增加一台服务器时，先虚拟150个节点，然后散落在哈希环上。
一致性哈希算法实现
Java代码：
public class ConsistentHashing {
private SortedMap<Integer, Node> hashCircle = new TreeMap<>();
private int virtualNums; // 虚拟节点数
public ConsistentHashing(Node[] nodes, int virtualNums) {
this.virtualNums = virtualNums;
// 初始化一致性hash环
for (Node node : nodes) {
// 创建虚拟节点
add(node);
}
}
/**
* 添加服务器节点
*
* @param node the server
*/
public void add(Node node) {
for (int i = 0; i < virtualNums; i++) {
hashCircle.put(hash(node.toString() + i), node);
}
}
/**
* 删除服务器节点
*
* @param node the server
*/
public void remove(Node node) {
for (int i = 0; i < virtualNums; i++) {
hashCircle.remove(hash(node.toString() + i));
}
}
/**
* 获取服务器节点
*
* @param key the key
* @return the server
*/
public Node getNode(String key) {
if (key == null || hashCircle.isEmpty())
return null;
int hash = hash(key);
if (!hashCircle.containsKey(hash)) {
// 未命中对应的节点
SortedMap<Integer, Node> tailMap = hashCircle.tailMap(hash);
hash = tailMap.isEmpty() ? hashCircle.firstKey() : tailMap.firstKey();
}
return hashCircle.get(hash);
}
/**
* FNV1_32_HASH算法
*
* @param key the key
* @return
*/
private int hash(String key) {
final int p = 16777619;
int hash = (int) 2166136261L;
for (int i = 0; i < key.length(); i++) {
hash = (hash ^ key.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 class Node {
private String ipAddr;
private int port;
private String name;
public Node(String ipAddr, int port, String name) {
this.ipAddr = ipAddr;
this.port = port;
this.name = name;
}
@Override
public String toString() {
return name + ":<" + ipAddr + ":" + port + ">";
}
}
}
评估服务器节点的负载均衡性
我们通过方差计算服务器节点的均衡性，代码如下：
public class ConsistentHashingTest {
public static void main(String[] args) {
ConsistentHashing.Node[] nodes = new ConsistentHashing.Node[4];
Map<ConsistentHashing.Node, List<String>> map = new HashMap<>();
// make nodes 4台服务器节点
for (int i = 0; i < nodes.length; i++) {
nodes[i] = new ConsistentHashing.Node("10.1.32.2" + i, 8070, "myNode" + i);
}
ConsistentHashing ch = new ConsistentHashing(nodes, 160);
// make keys 100万个key
String[] keys = new String[1_000_000];
for (int i = 0; i < keys.length; i++) {
keys[i] = "key" + (i + 17) + "ss" + (i * 19);
}
// make results
for (String key : keys) {
ConsistentHashing.Node n = ch.getNode(key);
List<String> list = map.computeIfAbsent(n, k -> new ArrayList<>());
list.add(key);
}
// 统计标准差，评估服务器节点的负载均衡性
int[] loads = new int[nodes.length];
int x = 0;
for (Iterator<ConsistentHashing.Node> i = map.keySet().iterator(); i.hasNext(); ) {
ConsistentHashing.Node key = i.next();
List<String> list = map.get(key);
loads[x++] = list.size();
}
int min = Integer.MAX_VALUE;
int max = 0;
for (int load : loads) {
min = Math.min(min, load);
max = Math.max(max, load);
}
System.out.println("最小值: " + min + "; 最大值: " + max);
System.out.println("方差：" + variance(loads));
}
public static double variance(int[] data) {
double variance = 0;
double expect = (double) sum(data) / data.length;
for (double datum : data) {
variance += (Math.pow(datum - expect, 2));
}
variance /= data.length;
return Math.sqrt(variance);
}
private static int sum(int[] data) {
int sum = 0;
for (int i = 0; i < data.length; i++) {
sum += data[i];
}
return sum;
}
}
测试结果：
# 虚拟节点是 120
最小值: 243919; 最大值: 253236
方差：3692.7378054771234
# 虚拟节点是 130
最小值: 240190; 最大值: 257384
方差：7432.346466628153
# 虚拟节点是 150
最小值: 233002; 最大值: 260369
方差：10227.744937179456
# 虚拟节点是 160
最小值: 241154; 最大值: 253743
方差：5150.429156876153
# 虚拟节点是 170
最小值: 235938; 最大值: 260044
方差：9244.906895150432
# 虚拟节点是 200
最小值: 233187; 最大值: 263222
方差：11395.83342717855
通过测试，每台物理服务的虚拟节点在120到200之间，均衡性更好。
总结
一致性hash算法解决了分布式环境下机器增加或者减少时，简单的取模运算无法获取较高命中率的问题。通过虚拟节点的使用，一致性hash算法可以均匀分担机器的负载，使得这一算法更具现实的意义。正因如此，一致性hash算法被广泛应用于分布式系统中。
