Week 05 命题作业

发布于: 2020 年 07 月 07 日

1.用你熟悉的编程语言实现一致性hash算法。

解答:

下面使用Java语言实现一致性Hash算法,由以下几个类/接口组成:

1.Node:真实节点类,比如可以保存真实节点的IP、端口号、节点名称、类型、用户名、密码等相关信息。

2.HashFunction:抽象的Hash方法策略接口。

3.MurMurHashFunctionImpl:具体的Hash方法策略实现类,使用MurMurHash算法。

4.FNV1_32HashFunctionImpl:具体的Hash方法策略实现类,使用FNV1_32_HASH算法。

5.ConsistentHash:一致性Hash算法核心类,持有一个Hash策略类的引用。

package com.yx.consistenthashing2;
/*
* 真实节点类,比如可以保存真实节点的IP、端口号、节点名称、类型、用户名、密码等相关信息。
*/
public class Node {
private String ip;// IP
private String port;// 端口
private String name;// 节点名称
private String type;// 节点类型
public Node(String ip, String port, String name, String type) {
this.ip = ip;
this.port = port;
this.name = name;
this.type = type;
}
public String getIp() {
return ip;
}
public void setIp(String ip) {
this.ip = ip;
}
public String getPort() {
return port;
}
public void setPort(String port) {
this.port = port;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
/**
* 重写Node的toString方法:
* 在一致性Hash算法核心类ConsistentHash中,使用节点IP做为Hash的基础KEY值
*/
@Override
public String toString() {
return ip;
}
}

package com.yx.consistenthashing2;
/*
* 抽象的Hash方法策略接口
*/
public interface HashFunction {
/**
* Hash函数
*
* @param key
* @return
*/
long hash(String key);
}

package com.yx.consistenthashing2;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
/*
* 具体的Hash方法策略实现类:使用MurMurHash算法
*/
public class MurMurHashFunctionImpl implements HashFunction {
/**
* MurMurHash算法,是非加密HASH算法,性能很高,碰撞率低
*/
@Override
public long hash(String key) {
ByteBuffer buf = ByteBuffer.wrap(key.getBytes());
int seed = 0x1234ABCD;
ByteOrder byteOrder = buf.order();
buf.order(ByteOrder.LITTLE_ENDIAN);
long m = 0xc6a4a7935bd1e995L;
int r = 47;
long h = seed ^ (buf.remaining() * m);
long k;
while (buf.remaining() >= 8) {
k = buf.getLong();
k *= m;
k ^= k >>> r;
k *= m;
h ^= k;
h *= m;
}
if (buf.remaining() > 0) {
ByteBuffer finish = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN);
finish.put(buf).rewind();
h ^= finish.getLong();
h *= m;
}
h ^= h >>> r;
h *= m;
h ^= h >>> r;
buf.order(byteOrder);
return h;
}
}

package com.yx.consistenthashing2;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
/*
* 具体的Hash方法策略实现类:使用FNV1_32_HASH算法
*/
public class FNV1_32HashFunctionImpl implements HashFunction {
/**
* FNV1_32_HASH算法,是FNV 32位散列函数
*/
@Override
public long hash(String key) {
final int p = 16777619;
long 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;
}
}

package com.yx.consistenthashing2;
import java.util.Collection;
import java.util.SortedMap;
import java.util.TreeMap;
/*
* 一致性Hash算法核心类
* 持有一个Hash策略类的引用
*/
public class ConsistentHash<T> {
private final HashFunction hashFunction;// Hash 函数接口 :使用策略模式,可自定义Hash算法实现类,然后在初始化当前类对象时注入
private final int numberOfReplicas;// 每个真实节点关所联的虚拟节点个数:该值越大,表示真实节点对应的虚拟节点越多,最终虚拟节点环上的节点数也就越多。
private final SortedMap<Long, T> circle = new TreeMap<Long, T>();// 存放环形虚拟节点的Map:key为自定义虚拟节点名称的Hash值;value表示每个虚拟节点对应的真实节点。
/**
*
* @param hashFunction
* Hash 函数接口
* @param numberOfReplicas
* 每个真实节点所关联的虚拟节点个数
* @param nodes
* 真实节点的集合
*/
public ConsistentHash(HashFunction hashFunction, int numberOfReplicas, Collection<T> nodes) {
this.hashFunction = hashFunction;
this.numberOfReplicas = numberOfReplicas;
for (T node : nodes) {
addVirtualNodes(node);
}
}
/**
* 增加环上真实节点对应的虚拟节点
*
* @param node
*/
public void addVirtualNodes(T node) {
for (int i = 0; i < this.numberOfReplicas; i++) {
circle.put(this.hashFunction.hash(node.toString() + i), node); //node.toString() + i 是自己定义的虚拟节点的命名规范
}
}
/**
* 删除环上真实节点对应的虚拟节点
*
* @param node
*/
public void remove(T node) {
for (int i = 0; i < this.numberOfReplicas; i++) {
circle.remove(this.hashFunction.hash(node.toString() + i));
}
}
/**
* 通过传入的记录标识,获取真实节点信息
*
* @param key
* @return
*/
public T get(String key) {
if (circle.isEmpty()) {
return null;
}
long hash = hashFunction.hash(key);
/*
* 判断环上是否存在传入key对应Hash值的虚拟节点:
* -如果有则直接返回该虚拟节点对应的真实节点的信息;
* -如果没有,则在环上进行虚拟节点的查找。
*/
if (!circle.containsKey(hash)) {
SortedMap<Long, T> tailMap = circle.tailMap(hash);// 沿环顺时针寻找大于传入key对应Hash值的所有节点
/*
* 根据传入key对应Hash值进行环上虚拟节点的查找:
* -如果没有比传入key的Hash值大的,则获取环上的第一个节点的key值;
* -如果有比传入key的Hash值大的,则返回沿环顺时针找到的第一个节点的key值。
*/
hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
}
return circle.get(hash); // 返回找到的虚拟节点对应的真实节点信息
}
}

2.编写测试用例测试这个算法,测试100万KV数据,10个服务器节点的情况下,计算这些KV数据在服务器上分布数量的标准差,以评估算法的存储负载不均衡性。

解答:

package com.yx.consistenthashing2;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
/*
* 一致性Hash算法测试类
*/
public class Test {
private static final String IP_PREFIX = "192.168.1.";// 定义真实节点对应的IP前缀:初始化真实节点测试用。
public static void main(String[] args) {
int allDataNum = 1000000;// 总记录数
int realNodeNum = 10;// 真实节点数
int virtualNodeNum = 248;// 每个真实节点对应的虚拟节点数
Map<String, Integer> countDatas = new HashMap<String, Integer>();// 用于记录每个真实节点上保存的记录条数:为了统计真实节点上分布的记录数。
List<Node> nodes = new ArrayList<Node>();// 存放真实节点的集合
// 模拟创建10个真实节点集群,实际应用时可以根据配置文件中的真实节点信息进行nodes集合的初始化。
for (int i = 1; i <= realNodeNum; i++) {
countDatas.put(IP_PREFIX + i, 0);// 将每个真实节点上保存的记录条数初始为0
Node node = new Node(IP_PREFIX + i, "6379", "node" + i, "Redis");// 创建真实节点对象
nodes.add(node);
}
HashFunction hashFunction = new MurMurHashFunctionImpl(); // 创建MurMurHash算法策略类实例
//HashFunction hashFunction = new FNV1_32HashFunctionImpl(); // 创建FNV1_32_HASH算法策略类实例
ConsistentHash<Node> consistentHash = new ConsistentHash<Node>(hashFunction, virtualNodeNum, nodes);// 创建一致性Hash算法核心类对象:让每个真实节点对应100个虚拟节点。
// 将100万条记录尽可能均匀的存储到10个真实节点
for (int i = 0; i < allDataNum; i++) {
// 模拟产生随机一个字符串当做一条记录,可以是其它更复杂的业务对象,比如随机字符串相当于对象的业务唯一标识
String data = UUID.randomUUID().toString() + i;
// 根据传入的记录获取对应的真实节点信息:通过一致性Hash算法核心类对象实现真实节点的选择。
Node node = consistentHash.get(data);
// 这里其实可以根据上面获得到的真实节点信息,将记录存储在真实节点对应的缓存服务器上,比如Redis、MemoryCache等
// ...
countDatas.put(node.getIp(), countDatas.get(node.getIp()) + 1); // 让每个真实节点上保存的记录条数加1
}
// 打印显示每个真实节点保存的记录数,查看数据分布情况
for (int i = 1; i <= realNodeNum; i++) {
System.out.println(IP_PREFIX + i + "真实节点记录条数:" + countDatas.get("192.168.1." + i));
}
// 计算真实节点上数据分布数量的标准差
int avg = allDataNum / realNodeNum;// 平均数
System.out.println("----------------------------------");
System.out.println("总记录数:"+allDataNum);
System.out.println("平均数:"+avg);
// 求方差
double allAbsSubPow = 0;// 单个数据和平均数的差的绝对值的平方的总和
for (int i = 1; i <= realNodeNum; i++) {
int nodeDataNum = countDatas.get("192.168.1." + i);// 获取每个真实节点上的记录数
int absSub = Math.abs(nodeDataNum - avg);// 求出单个数据和平均数的差的绝对值
allAbsSubPow += Math.pow(absSub, 2);
}
double variance = allAbsSubPow / realNodeNum;// 方差
System.out.println("方差 : "+variance);
// 求标准差
double standardDeviation = Math.sqrt(variance);
System.out.println("标准差:"+standardDeviation);
}
}

因为100万条数据使用UUID表示了,所以以上代码每次执行结果是不同的,其中一次执行结果如下:

192.168.1.1真实节点记录条数:99245
192.168.1.2真实节点记录条数:96709
192.168.1.3真实节点记录条数:99682
192.168.1.4真实节点记录条数:99937
192.168.1.5真实节点记录条数:100939
192.168.1.6真实节点记录条数:103116
192.168.1.7真实节点记录条数:104327
192.168.1.8真实节点记录条数:97181
192.168.1.9真实节点记录条数:101294
192.168.1.10真实节点记录条数:97570
----------------------------------
总记录数:1000000
平均数:100000
方差 : 5634600.2
标准差:2373.7312821800197

用户头像

卧石漾溪

关注

还未添加个人签名 2020.05.04 加入

还未添加个人简介

评论

发布
暂无评论
Week 05 命题作业