一致性哈希

传统哈希的问题：

1.节点动态改变：
例如，原先的hash规则是key%4，增加节点后规则变为key%5，为保证存量数据可以背准确映射，需对其进行数据迁移（rebalance）
又例如，原先的hash规则是key%4，删除一个节点后规则变为key%3，导致缓存击穿缓存雪崩

一致性哈希：节点动态增加/改变造成的数据迁移/缓存穿透的成本最小
1.原理：我们将节点映射在0-2^32的环上,对请求进行hash运算，得到请求的hashcode，顺时针查找最近的节点，即为找到请求与节点的映射关系。

2.虚节点的引入：
2.2问题：如果节点数目较少，且分布不够离散，则会导致负载不均衡。
2.3解决：对于每个节点，会对应若干个虚节点，请求映射到虚节点上，虚节点在对应到真实节点，增加节点离散性。

3.实现：

package com.test.server;


import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.List;
import java.util.Objects;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * thread unsafe
 * copyright 
 */
public class HashServer {
    private static final int NODE_NUM = 3;
    private volatile int nodeNum;
    /**
     * thread unsafe
     */
    private TreeMap<Long, Node> serverNodes = new TreeMap<>();
    private List<Node> serverList = new CopyOnWriteArrayList<>();

    public Node findServer(String key) {
        long l = md5Digest(key);
        SortedMap<Long, Node> sortedMap = serverNodes.tailMap(l);
        Long k = null;
        if (sortedMap.isEmpty()) {
            k = serverNodes.firstKey();
        } else {
            k = sortedMap.firstKey();
        }
        Node node = serverNodes.get(k);
        System.out.println("find node by key,hash=" + l + " node key=" + k + " node=" + node.toString());
        return node;
    }

    public void remove(String name, String ip) {
        if (nodeNum <= 0) {
            return;
        }
        for (int i = 0; i < nodeNum; i++) {
            long l = md5Digest(keyKitWithVitralNode(name, ip, nodeNum));
            serverNodes.remove(l);
        }
        Node node = new Node();
        node.setIp(ip);
        node.setName(name);
        //array list with remove node accounting to equals() method;
        //the same ip and name node can be removed
        // because of implements equals method,
        serverList.remove(node);
    }

    public void createServer(String name, String ip) {
        createServer(name, ip, NODE_NUM);
    }

    private void createServer(String name, String ip, int nodeNum) {
        if (nodeNum <= 0) {
            nodeNum = 0;
        }
        this.nodeNum = nodeNum;
        if (nodeNum == 0) {
            return;
        }
        Node node = new Node();
        node.setName(name);
        node.setIp(ip);
        serverList.add(node);
        for (int i = 0; i < nodeNum; i++) {
            //生成n个虚拟节点
            long l = md5Digest(keyKitWithVitralNode(name, ip, i));
            serverNodes.put(l, node);
            System.out.println(node.toString() + "-" + "第 " + i + "个节点" + "hash=" + l);
        }

    }


    /**
     * 取Md5并散列到0~2^32-1上
     */
    private long md5Digest(String key) {
        MessageDigest md5 = null;
        try {
            md5 = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException e) {
            //不做处理。“MD5”是写死的，不可能抛异常
        }
        md5.reset();
        md5.update(key.getBytes());
        byte[] bKey = md5.digest();
        return ((long) (bKey[3] & 0xFF) << 24)
                | ((long) (bKey[2] & 0xFF) << 16)
                | ((long) (bKey[1] & 0xFF) << 8)
                | (long) (bKey[0] & 0xFF);
    }

    private String keyKit(String name, String ip) {
        return name + ":" + ip;
    }


    private String keyKitWithVitralNode(String name, String ip, int index) {
        return name + ":" + ip + ":" + index;
    }

    private static class Node {
        private String name;
        private String ip;

        public String getIp() {
            return ip;
        }

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

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Node node = (Node) o;
            return Objects.equals(name, node.name) &&
                    Objects.equals(ip, node.ip);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name, ip);
        }

        @Override
        public String toString() {
            return "Node{" +
                    "name='" + name + '\'' +
                    ", ip='" + ip + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) {
        HashServer hashServer = new HashServer();
        hashServer.createServer("node1", "192.168.10.2");
        hashServer.createServer("node2", "192.168.10.1");
        hashServer.findServer("aaa");
    }
}

4.运行结果：