图解一致性哈希算法，看这一篇就够了！

public class Node {    private static final int VIRTUAL_NODE_NO_PER_NODE = 200;    private final String ip;    private final List<Integer> virtualNodeHashes = new ArrayList<>(VIRTUAL_NODE_NO_PER_NODE);    private final Map<Object, Object> cacheMap = new HashMap<>();
    public Node(String ip) {        Objects.requireNonNull(ip);        this.ip = ip;        initVirtualNodes();    }

    private void initVirtualNodes() {        String virtualNodeKey;        for (int i = 1; i <= VIRTUAL_NODE_NO_PER_NODE; i++) {            virtualNodeKey = ip + "#" + i;            virtualNodeHashes.add(HashUtils.hashcode(virtualNodeKey));        }    }
    public void addCacheItem(Object key, Object value) {        cacheMap.put(key, value);    }

    public Object getCacheItem(Object key) {        return cacheMap.get(key);    }

    public void removeCacheItem(Object key) {        cacheMap.remove(key);    }

    public List<Integer> getVirtualNodeHashes() {        return virtualNodeHashes;    }
    public String getIp() {        return ip;    }}

public class ConsistentHash {    private final TreeMap<Integer, Node> hashRing = new TreeMap<>();
    public List<Node> nodeList = new ArrayList<>();
    /**     * 增加节点     * 每增加一个节点，就会在闭环上增加给定虚拟节点     * 例如虚拟节点数是2，则每调用此方法一次，增加两个虚拟节点，这两个节点指向同一Node     * @param ip     */    public void addNode(String ip) {        Objects.requireNonNull(ip);        Node node = new Node(ip);        nodeList.add(node);        for (Integer virtualNodeHash : node.getVirtualNodeHashes()) {            hashRing.put(virtualNodeHash, node);            System.out.println("虚拟节点[" + node + "] hash:" + virtualNodeHash + "，被添加");        }    }
    /**     * 移除节点     * @param node     */    public void removeNode(Node node){        nodeList.remove(node);    }
    /**     * 获取缓存数据     * 先找到对应的虚拟节点，然后映射到物理节点     * @param key     * @return     */    public Object get(Object key) {        Node node = findMatchNode(key);        System.out.println("获取到节点:" + node.getIp());        return node.getCacheItem(key);    }
    /**     * 添加缓存     * 先找到hash环上的节点，然后在对应的节点上添加数据缓存     * @param key     * @param value     */    public void put(Object key, Object value) {        Node node = findMatchNode(key);
        node.addCacheItem(key, value);    }
    /**     * 删除缓存数据     */    public void evict(Object key) {        findMatchNode(key).removeCacheItem(key);    }

    /**     *  获得一个最近的顺时针节点     * @param key 为给定键取Hash，取得顺时针方向上最近的一个虚拟节点对应的实际节点     *      * @return 节点对象     * @return     */    private Node findMatchNode(Object key) {        Map.Entry<Integer, Node> entry = hashRing.ceilingEntry(HashUtils.hashcode(key));        if (entry == null) {            entry = hashRing.firstEntry();        }        return entry.getValue();    }}

public class HashUtils {
    /**     * FNV1_32_HASH     *     * @param obj     *         object     * @return hashcode     */    public static int hashcode(Object obj) {        final int p = 16777619;        int hash = (int) 2166136261L;        String str = obj.toString();        for (int i = 0; i < str.length(); i++)            hash = (hash ^ str.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);        //System.out.println("hash computer:" + hash);        return hash;    }}

public class ConsistentHashTest {    public static final int NODE_SIZE = 10;    public static final int STRING_COUNT = 100 * 100;    private static ConsistentHash consistentHash = new ConsistentHash();    private static List<String> sList = new ArrayList<>();
    public static void main(String[] args) {        // 增加节点        for (int i = 0; i < NODE_SIZE; i++) {            String ip = new StringBuilder("10.2.1.").append(i)                    .toString();            consistentHash.addNode(ip);        }
        // 生成需要缓存的数据;        for (int i = 0; i < STRING_COUNT; i++) {            sList.add(RandomStringUtils.randomAlphanumeric(10));        }
        // 将数据放入到缓存中。        for (String s : sList) {            consistentHash.put(s, s);        }
        for(int i = 0 ; i < 10 ; i ++) {            int index = RandomUtils.nextInt(0, STRING_COUNT);            String key = sList.get(index);            String cache = (String) consistentHash.get(key);            System.out.println("Random:"+index+",key:" + key + ",consistentHash get value:" + cache +",value is:" + key.equals(cache));        }
        // 输出节点及数据分布情况        for (Node node : consistentHash.nodeList){            System.out.println(node);        }
        // 新增一个数据节点        consistentHash.addNode("10.2.1.110");        for(int i = 0 ; i < 10 ; i ++) {            int index = RandomUtils.nextInt(0, STRING_COUNT);            String key = sList.get(index);            String cache = (String) consistentHash.get(key);            System.out.println("Random:"+index+",key:" + key + ",consistentHash get value:" + cache +",value is:" + key.equals(cache));        }
        // 输出节点及数据分布情况        for (Node node : consistentHash.nodeList){            System.out.println(node);        }    }}