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 年 07 月 07 日阅读数: 54
卧石漾溪

 关注
还未添加个人签名 2020.05.04 加入
还未添加个人简介
发布
暂无评论