1、Hash算法在缓存系统中应用
1.1 说明
在一个系统中，为了降低对后端数据库的压力，增加了专门的缓存服务器。每次请求时，先对请求要素做Hash，计算出命中哪个服务器(最简单的，有n台缓存服务器，可以采用将请求要素%n的方式，得到的结果就是服务器序号)，然后去请求这个缓存服务器：
- 如果有结果直接返回；
- 如果没有结果，就请求后端数据库，然后，将结果放在这台缓存服务器中，方便下次请求查询。
1.2 缺点
这种场景下，有一个问题，当缓存服务器的台数发生变化时，会有大规模的缓存失效。
比如，n台服务器中，有一台缓存服务器故障下线了，那么这时候计算命中哪台缓存服务器的算法，就变成了对应的%(n-1)。这样，大量的缓存就都失效了。
同样地，如果添加缓存服务器，也会出现这种缓存失效的情况。
2、一致性Hash算法介绍
2.1 简单说明
前面场景中的问题，可以通过一致性Hash算法，来解决。思路其实特别简单，就是将原来的Hash桶，放在一个圆环(Hash环)上，计算后的Hash值，按照一定的方向(顺时针或者逆时针都可以)，距离那个桶最近，就认为当前命中哪个桶。
2.2 程序实现思路
在程序中，无法实现原生的圆环结构，只能是通过线性结构模拟。模拟的方式很简单，只需要当找不到更大的hash值时，认为是落到第一个桶就好了。
2.3 解决分布不均的问题
这样的方法，会有一个问题，就是Hash桶中的数据分布不均匀。为了解决这个问题，可以对每一个Hash桶，分配多个虚拟节点分布在Hash环上。这样，每个桶的虚拟节点越多，数据分布就会越均匀。
2.4 程序实现
这里介绍java程序的实现，首先要了解java.util.TreeMap.tailMap()用法：
描述：
这个tailMap(K fromKey)方法用于返回此映射中键大于或等于 fromKey 的部分的视图。返回的Map由此Map支持，因此返回的Map中的更改会反映在此Map中，反之亦然。
声明：
以下是声明java.util.TreeMap.tailMap()方法。
public SortedMap<K,V> tailMap(K fromKey)
参数：
fromKey- 这是返回映射中键的低端点(包括)。
返回值：
该方法调用返回此映射中键大于或等于 fromKey 的部分的视图。
一致性Hash的java实现：
package com.lfqy.trying.consistenthash;
import java.util.SortedMap;
import java.util.TreeMap;
/**
* Created by chengxia on 2023/3/9. */public class ConsistentHash {
private SortedMap<Integer, Node> hashCircle = new TreeMap<>();
private int virtualNums; // 虚拟节点数
public ConsistentHash(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 + ">";
}
}
}
这个例子实现，依赖于java的原生结构，非常好的展现了TreeMap和SortedMap这两个结构的使用。
如下的程序，用来计算该一致性Hash算法的数据分布最大值、最小值和方差。
package com.lfqy.trying.consistenthash;
import java.util.*;
/**
* Created by chengxia on 2023/3/9. */public class ConsistentHashTest {
public static void main(String[] args) {
ConsistentHash.Node[] nodes = new ConsistentHash.Node[4];
Map<ConsistentHash.Node, List<String>> map = new HashMap<>();
// make nodes 4台服务器节点
for (int i = 0; i < nodes.length; i++) {
nodes[i] = new ConsistentHash.Node("10.1.32.2" + i, 8070, "myNode" + i);
}
ConsistentHash ch = new ConsistentHash(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) {
ConsistentHash.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<ConsistentHash.Node> i = map.keySet().iterator(); i.hasNext(); ) {
ConsistentHash.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;
}
}
运行后，输出如下：
最小值: 241154; 最大值: 253743
方差：5150.429156876153
Process finished with exit code 0
