前言

这部分问题知识在面试中经常被问到，而且是高频中的高频

场景拓展：
要缓存某些数据，放在N台服务器，也就是将其平摊分配这些数据，达到一个缓存的效果。但是如果要找到这些数据的时候，是通过遍历全部服务器，就会失去缓存的意义

原始的做法是对缓存项的key中进行哈希，之后value进行取模操作，决定分配数据在哪台服务器。如果要找这些数据的时候就不用遍历了

hash% N，这个为具体的公式，主要是通过取模运算

但这种算法会有缺陷，原本N台服务器已经缓存好数据了，现在多增加服务器，会导致缓存数据的变换。如果减少服务器，缓存的位置以及数量也会发生变换。大量缓存在同一时间失效，造成缓存雪崩的现象。

一致性哈希算法

为了解决上面的缺陷，一致性哈希算法由此诞生
（取模法是对服务器的数量进行取模，而一致性哈希算法是对2^32^取模）

假设有三台服务器，可以将其服务器ip地址或者其他标志性的东西作为key值进行hash，只不过取模的时候用的是2³²，将其一一映射到环中。之后对应的数据也进行映射，之后沿顺时针的方向，距离最近的服务器就是缓存服务器（A）。具体情况如下所示

对于缓存雪崩造成的问题，所有服务器的所有缓存在同一时间失效了。
而使用一致性哈希算法时，服务器的数量如果发生改变，并不是所有缓存都会失效，而是只有部分缓存会失效。

数据倾斜的问题

如下所示
理想与现实会造成一定的区别，缓存往往会极度不均衡的分布在各服务器上
可能映射的时候会造成数据倾斜，导致某一部分的服务器有些压力，有些服务器却很轻松

为了能让这3台服务器尽量多的、均匀的出现在hash环上
设置一些虚拟节点。“虚拟节点”是”实际节点”（实际的物理服务器）在hash环上的复制品,一个实际节点可以对应多个虚拟节点

也就是1和4的数据在服务器C中，2和3的数据在服务器A上
（主要是为了讲解虚拟节点，设置可能刚刚好或者没那么均匀而已，主要是为了讲解明白而已，草图可忽略）每台机器映射的虚拟节点越多，则分布的越均匀~~~

代码应用

具体这部分代码主要是参考这一篇文章
详情可看该链接
一致性hash算法应用

算法接口

public interface IHashService {
    Long hash(String key);
}

接口实现类

public class HashService implements IHashService {

    /**
     * MurMurHash算法,性能高,碰撞率低
     *
     * @param key String
     * @return Long
     */
    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;

    }
}

模拟机器节点

public class Node<T> {
    private String ip;
    private String name;

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

    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;
    }

    /**
     * 使用IP当做hash的Key
     *
     * @return String
     */
    @Override
    public String toString() {
        return ip;
    }
}

一致性hash算法

public class ConsistentHash<T> {
    // Hash函数接口
    private final IHashService iHashService;
    // 每个机器节点关联的虚拟节点数量
    private final int          numberOfReplicas;
    // 环形虚拟节点
    private final SortedMap<Long, T> circle = new TreeMap<Long, T>();

    public ConsistentHash(IHashService iHashService, int numberOfReplicas, Collection<T> nodes) {
        this.iHashService = iHashService;
        this.numberOfReplicas = numberOfReplicas;
        for (T node : nodes) {
            add(node);
        }
    }

    /**
     * 增加真实机器节点
     *
     * @param node T
     */
    public void add(T node) {
        for (int i = 0; i < this.numberOfReplicas; i++) {
            circle.put(this.iHashService.hash(node.toString() + i), node);
        }
    }

    /**
     * 删除真实机器节点
     *
     * @param node T
     */
    public void remove(T node) {
        for (int i = 0; i < this.numberOfReplicas; i++) {
            circle.remove(this.iHashService.hash(node.toString() + i));
        }
    }

    public T get(String key) {
        if (circle.isEmpty()) return null;

        long hash = iHashService.hash(key);

        // 沿环的顺时针找到一个虚拟节点
        if (!circle.containsKey(hash)) {
            SortedMap<Long, T> tailMap = circle.tailMap(hash);
            hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
        }
        return circle.get(hash);
    }
}

测试类

public class TestHashCircle {
    // 机器节点IP前缀
    private static final String IP_PREFIX = "192.168.0.";

    public static void main(String[] args) {
        // 每台真实机器节点上保存的记录条数
        Map<String, Integer> map = new HashMap<String, Integer>();

        // 真实机器节点, 模拟10台
        List<Node<String>> nodes = new ArrayList<Node<String>>();
        for (int i = 1; i <= 10; i++) {
            map.put(IP_PREFIX + i, 0); // 初始化记录
            Node<String> node = new Node<String>(IP_PREFIX + i, "node" + i);
            nodes.add(node);
        }

        IHashService iHashService = new HashService();
        // 每台真实机器引入100个虚拟节点
        ConsistentHash<Node<String>> consistentHash = new ConsistentHash<Node<String>>(iHashService, 500, nodes);

        // 将5000条记录尽可能均匀的存储到10台机器节点上
        for (int i = 0; i < 5000; i++) {
            // 产生随机一个字符串当做一条记录，可以是其它更复杂的业务对象,比如随机字符串相当于对象的业务唯一标识
            String data = UUID.randomUUID().toString() + i;
            // 通过记录找到真实机器节点
            Node<String> node = consistentHash.get(data);
            // 再这里可以能过其它工具将记录存储真实机器节点上，比如MemoryCache等
            // ...
            // 每台真实机器节点上保存的记录条数加1
            map.put(node.getIp(), map.get(node.getIp()) + 1);
        }

        // 打印每台真实机器节点保存的记录条数
        for (int i = 1; i <= 10; i++) {
            System.out.println(IP_PREFIX + i + "节点记录条数：" + map.get(IP_PREFIX + i));
        }
    }
}