一致性hash算法

1、准备工作—hash算法

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
/**
 * @Describe: 实现一致性哈希算法中使用的哈希函数,
    使用MD5算法来保证一致性哈希的平衡性
 * @Author: liuyj
 * @Date: 2022-08-26 16:36
 */
public class HashFunction {
    private MessageDigest md5 = null;

    public long hash(String key) {

        if (md5 == null) {
            try {
                md5 = MessageDigest.getInstance("MD5");
            } catch (NoSuchAlgorithmException e) {
                throw new IllegalStateException("no md5 algrithm found");
            }
        }
        md5.reset();
        md5.update(key.getBytes());
        byte[] bKey = md5.digest();

        //具体的哈希函数实现细节--每个字节 & 0xFF 再移位
        long result = ((long) (bKey[3] & 0xFF) << 24)
                | ((long) (bKey[2] & 0xFF) << 16
                | ((long) (bKey[1] & 0xFF) << 8)
                | (long) (bKey[0] & 0xFF));

        return result & 0xffffffffL;
    }
}

2、一致性hash算法

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * @Describe:一致性hash函数
 * @Author: liuyj
 * @Date: 2022-08-26 16:40
 */
public class ConsistentHash<T> {
    private final HashFunction hashFunction;
    private final int numberOfReplicas;

    // 节点的复制因子,实际节点个数 * numberOfReplicas =虚拟节点个数
    private final SortedMap<Long,Object> circle = new TreeMap<>();

    // 存储虚拟节点的hash值到真实节点的映射
    public ConsistentHash(HashFunction hashFunction, int numberOfReplicas,
                          Collection<T> nodes){
        this.hashFunction = hashFunction;
        this.numberOfReplicas = numberOfReplicas;
        for (T node : nodes)
            add(node);
    }

    public void add(T node){
        // 对于一个实际机器节点 node, 对应 numberOfReplicas 个虚拟节点
        for (int i = 0; i < numberOfReplicas; i++){
            /*
             * 不同的虚拟节点(i不同)有不同的hash值,但都对应同一个实际机器node
             * 虚拟node一般是均衡分布在环上的,数据存储在顺时针方向的虚拟node上
             */
            circle.put(hashFunction.hash(node.toString() + i), node);
        }
    }

    public void remove(T node){
        for (int i = 0; i < numberOfReplicas; i++)
            circle.remove(hashFunction.hash(node.toString() + i));
    }

    /**
     * 获得一个最近的顺时针节点,根据给定的key 取Hash
     * 然后再取得顺时针方向上最近的一个虚拟节点对应的实际节点
     * 再从实际节点中取得 数据
     */
    public T get(Object key){
        if (circle.isEmpty()){
            return null;
        }
        long hash = hashFunction.hash((String) key);

        // node 用String来表示,获得node在哈希环中的hashCode
        if (!circle.containsKey(hash)) {
            //数据映射在两台虚拟机器所在环之间,就需要按顺时针方向寻找机器
            SortedMap tailMap = circle.tailMap(hash);
            hash = tailMap.isEmpty() ? circle.firstKey() : (long) tailMap.firstKey();
        }
        return (T) circle.get(hash);
    }

    public long getSize(){
        return circle.size();
    }

    // 查看MD5算法生成的hashCode值---表示整个哈希环中各个虚拟节点位置
    public void testBalance(){

        Set sets  = circle.keySet();
        //获得TreeMap中所有的Key
        SortedSet<Long> sortedSets= new TreeSet(sets);
        //将获得的Key集合排序
        for(Long hashCode : sortedSets){
            System.out.println(hashCode);
        }
        System.out.println("----each location 's distance are follows: ----");

        // 查看用MD5算法生成的long hashCode 相邻两个hashCode的差值
        Iterator it = sortedSets.iterator();
        Iterator it2 = sortedSets.iterator();
        if(it2.hasNext()){
            it2.next();
        }

        long keyPre, keyAfter;
        while(it.hasNext() && it2.hasNext()){
            keyPre = (long) it.next();
            keyAfter = (long) it2.next();
            System.out.println(keyAfter - keyPre);
        }
    }

    public static void main(String[] args){
        Set<String> nodes = new HashSet<>();
        nodes.add("A");
        nodes.add("B");
        nodes.add("C");
        ConsistentHash consistentHash = new ConsistentHash(new HashFunction(), 2, nodes);
        consistentHash.add("D");
        System.out.println("hash circle size: " + consistentHash.getSize());
        System.out.println("location of each node are follows: ");
        consistentHash.testBalance();
    }
}

3、具体应用—解决数据迁移问题讲解

3.1如何解决集群中添加或者删除机器上需要迁移大量数据的问题？

假设采用传统的哈希取模法，设有K台物理机，H(key)=hash(key) mod K 即可实现数据分片。但当K变化时(如新增一台机器)，所有已经映射好的数据都需要重新再映射。H(key)=hash(key) mod (K+1)。

一致性哈希采用的做法如下：

• 引入一个环的概念。
• 先将机器映射到这个环上，再将数据也通过相同的哈希函数映射到这个环上，数据存储在它顺时针走向的那台机器上。
• 以环为中介，实现了数据与机器数目之间的解藕。
• 这样，当机器的数目变化时，只会影响到增加或删除的那台机器所在的环的邻接机器的数据存储，而其他机器上的数据不受影响。

在具体JAVA实现代码中，定义了一个TreeMap用来保存虚拟机器节点到实际的物理机器的映射。机器以字符串形式来标识，故hash函数的参数为String

?

1 2 3 4 5 6 7 8

// 对于一个实际机器节点 node, 对应 numberOfReplicas 个虚拟节点 for (int i = 0; i < numberOfReplicas; i++){     /*     * 不同的虚拟节点(i不同)有不同的hash值,但都对应同一个实际机器node     * 虚拟node一般是均衡分布在环上的,数据存储在顺时针方向的虚拟node上     */     circle.put(hashFunction.hash(node.toString() + i), node); }

而对于 数据的存储而言，逻辑上是按顺时针方向存储在虚拟机器节点中，虚拟机器节点通过TreeMap知道它实际需要将数据存储在哪台物理机器上。此外，TreeMap中的Key是有序的，而环也是顺时针有序的，这样才能当数据被映射到两台虚拟机器之间的弧上时，通过TreeMap的 tailMap()来寻找顺时针方向上的下一台虚拟机。

?

1 2 3 4 5

if (!circle.containsKey(hash)) { //数据映射在两台虚拟机器所在环之间,就需要按顺时针方向寻找机器 SortedMap tailMap = circle.tailMap(hash); hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey(); }