一致性哈希算法

算法应用

这是一种路由算法，适用于大部分的路由场景，优点是在伸缩性需求较高的场景中可以提高命中率。

算法思路

先构造一个长度为2的32次方的整数环（这个环被称为一致性Hash环），根据节点名称的Hash值（其分布为[-2^31, 2^{31)）将缓存服务器节点放置在这个Hash环上，然后根据需要缓存的数据的Key值计算得到其Hash值（其分布也为[-2}31, 2^31)），然后在Hash环上顺时针查找距离这个Key值的Hash值最近的服务器节点，完成Key到服务器的映射查找。

实现方式（java、虚拟节点）

• 使用TreeMap 作为一致性Hash环的数据结构，查找快。
• 需要确定采用的Hash算法，确保计算得到的Hash值落在int整数区间内。
• 一个物理节点对应虚拟节点数量为virtualNum。
• 需要实现增加节点、删除节点、根据数据key得到服务器节点的方法。

所以实现如下

先定义一个Hash算法策略接口，将具体算法与业务代码解耦

public interface HashStrategy {
    int hash(Object key);
}

增加一个实现类，这里采用MD5来实现，实际上具体实现方式最好由算法专家来确定

public class MD5HashImpl implements HashStrategy{

    MessageDigest digest;

    public MD5HashImpl() throws NoSuchAlgorithmException {
        this.digest = MessageDigest.getInstance("MD5");
    }

    @Override
    public int hash(Object key) {

        if(key == null){
            return 0;
        }

        int h = key.hashCode();

        //开32位的空间
        byte[] bytes = new byte[4];

        //将h赋值给bytes数组
        for (int i=3;i>-1;i--){
            bytes[i] = (byte)(h>>(i*8));
        }

        byte[] hashBytes;

        synchronized (digest){
            hashBytes = digest.digest(bytes);
        }

        int result = 0;
        for(int i=0; i<4 ;i++){
            int idx = i*4;
            result += (hashBytes[idx + 3]&0xFF << 24)
                    | (hashBytes[idx + 2]&0xFF << 16)
                    | (hashBytes[idx + 1]&0xFF << 8)
                    | (hashBytes[idx + 0]&0xFF);
        }
        return result;
    }
}

定义服务器节点抽象类，这里定义一个简单版本

public class Node {
    /**
     * 主机ip
     */
    private String ip;

    /**
     * 代表该主机中存放的KV
     */
    private ConcurrentHashMap map = new ConcurrentHashMap();

    public Node(String ip) {
        this.ip = ip;
    }

    public String getIp() {
        return ip;
    }

    public void setIp(String ip) {
        this.ip = ip;
    }

    public ConcurrentHashMap getMap() {
        return map;
    }
}

最后便是一致性hash算法的实现

首先是直接在一致性hash环中增加物理节点的方式

public class ConsistentHash {

    private final SortedMap<Integer,Node> circle = new TreeMap<>();

    private HashStrategy hashStrategy;

    public ConsistentHash(HashStrategy hashStrategy) {
        this.hashStrategy = hashStrategy;
    }

    public void addNode(Node node){
        circle.put(hashStrategy.hash(node.getIp()),node);
    }

    public void removeNode(Node node){
        circle.remove(hashStrategy.hash(node.getIp()));
    }

    /**
     * 根据key查找服务器节点
     * @param key
     * @return
     */
    public Node getNode(Object key){
        int hashCode = hashStrategy.hash(key);

        if(!circle.containsKey(hashCode)){
            //顺时针取得最近的节点
            SortedMap<Integer,Node> tailMap = circle.tailMap(hashCode);
            hashCode = tailMap.isEmpty()?circle.firstKey():tailMap.firstKey();
        }

        return circle.get(hashCode);
    }
}

如果要增加虚拟节点，只需要讲add和remove方法重写，如果追求代码优美，可以将物理节点与虚拟节点的映射方式定义一个接口。

public class ConsistentHashWithVirtualNode {
    private final SortedMap<Integer, Node> circle = new TreeMap<>();

    private HashStrategy hashStrategy;

    private int virtualNum; // 把实际节点虚拟为多少个节点

    public ConsistentHashWithVirtualNode(HashStrategy hashStrategy, int virtualNum) {
        this.hashStrategy = hashStrategy;
        this.virtualNum = virtualNum;
    }

    public void addNode(Node node) {
        for (int i = 0; i < virtualNum; i++) {
            circle.put(hashStrategy.hash(i + node.getIp()), node);
        }
    }

    public void removeNode(Node node) {
        for (int i = 0; i < virtualNum; i++) {
            circle.remove(hashStrategy.hash(i + node.getIp()));
        }
    }

    /**
     * 根据key查找服务器节点
     *
     * @param key
     * @return
     */
    public Node getNode(Object key) {
        int hashCode = hashStrategy.hash(key);

        if (!circle.containsKey(hashCode)) {
            //顺时针取得最近的节点
            SortedMap<Integer, Node> tailMap = circle.tailMap(hashCode);
            hashCode = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
        }

        return circle.get(hashCode);
    }
}

对于一个物理节点对应多少虚拟节点较好，貌似有一个经验值图标，在此不列出。