一致性Hash思想及实现记录一下

前言

• 之前公司有个业务需求，把一批用户信息保存到本地库，数据大概有100万+，而且后期一段时间也会持续性加入本地库，为了保证后期风控查询匹配，所以用了分表模式
• 当时评估了后期的数据量，也是对一致性hash算法了解不多，所以采用了用户唯一信息hash并取模方式插入数据库。
• 采用hash取模方式虽然简单高效，但对数据或节点进行扩容或者缩容，取模的方式就行不通的。
• 这时就可以使用一致性hash算法来解决这种问题

一致性Hash设计思想

• 一致性Hash是由固定长度的hash环构成，其大小为2的32次方。将数据或节点计算出hash值为key放入到hash环中。
• 在获取节点时通过计算出hash值为key找到在hash环中位置，再按照顺时针找到最近的一个节点数据。
• 上述情况会出现一个分配失衡的问题，在hash环内只有少数的节点数据，会导致某些节点数据命中率过高，有些节点数据命中率过低
• 这时就需要使用虚拟节点，为每个真实节点创建出一些虚拟节点，在均匀的放入hash环内。

• 注：这里为每个真实节点创建的虚拟节点不用都是一致数量的，比如节点存放的是服务节点，那可以根据不同的服务配置不同的虚拟节点数量，某些服务所在机器配置高可以多配置一些虚拟节点，这样命中率高一些。某些服务所在机器配置低一些，就可以少配置一下虚拟节点，这样命中率就第一些。

Java代码实现

• 废话不说，直接 show code

/**
 * 一致性hash实现
 *
 * @Author: ZRH
 * @Date: 2021/8/19 16:06
 */
public class OneHash {

    /**
     * 每个正式节点所构建的虚拟节点大小（虚拟节点集合总大小 = SIZE * SERVICE.length）
     */
    private final static Integer SIZE = 100;
    /**
     * 存放虚拟节点数据集合（真实节点不会放入此集合）
     */
    private final static SortedMap<Integer, String> FALSE_MAP = new TreeMap<>();
    /**
     * 存放真实节点数据集合
     */
    private final static List<String> TRUE_LIST = new ArrayList<>();
    /**
     * 一些默认正式节点数据
     */
    private final static String[] SERVICE = new String[]{"192.168.0.1", "192.168.0.2", "192.168.0.3", "192.168.0.4", "192.168.0.5"};

    static {
        for (int i = 0; i < SERVICE.length; i++) {
            // 将正式节点数据放入集合
            TRUE_LIST.add(SERVICE[i]);
            for (int j = 0; j < SIZE; j++) {
                // 构建虚拟节点数据并放入集合
                String value = SERVICE[i] + "&" + j;
                int hash = buildHash(value);
                FALSE_MAP.put(hash, value);
            }
        }
    }

    /**
     * 获取节点所匹配的真实节点
     *
     * @param node
     * @return
     */
    private static String getService (String node) {
        int hash = buildHash(node);
        Integer nodeKey;
        // 获取虚拟节点集合中比此node的hash值等于或大于的集合
        SortedMap<Integer, String> nodeMap = FALSE_MAP.tailMap(hash);
        if (nodeMap.isEmpty()) {
            // 如果获取的集合为null，说明此node的hash值超出虚拟节点集合中最大的hash-key，那就直接获取虚拟节点中最后一个（这里根据自身场景或业务可自定义决定取哪个，不用非要取最后一个，也可以取集合第一个）
            nodeKey = FALSE_MAP.lastKey();
        } else {
            // 获取集合中第一个节点（相当于按顺时针取最近的节点）
            nodeKey = nodeMap.firstKey();
        }
        // 通过虚拟节点获取真实节点数据
        String service = FALSE_MAP.get(nodeKey).split("&")[0];
        // 判断此真实节点数据是否在真实节点集合中
        if (TRUE_LIST.contains(service)) {
            return service;
        }
        return null;
    }

    /**
     * 添加一个真实节点
     *
     * @param node
     */
    private static void addService (String node) {
        if (null == node || TRUE_LIST.contains(node)) {
            return;
        }
        // 真实节点集合加入数据，虚拟节点集合也加入数据
        TRUE_LIST.add(node);
        for (int j = 0; j < SIZE; j++) {
            String value = node + "&" + j;
            int hash = buildHash(value);
            FALSE_MAP.put(hash, value);
        }
    }

    /**
     * 删除一个真实节点
     *
     * @param node
     */
    private static void deleteService (String node) {
        if (null == node || !TRUE_LIST.contains(node)) {
            return;
        }
        // 真实节点集合删除数据，虚拟节点集合也删除数据
        TRUE_LIST.remove(node);
        for (int j = 0; j < SIZE; j++) {
            String value = node + "&" + j;
            FALSE_MAP.remove(buildHash(value));
        }
    }

    /**
     * FNV1_32_HASH算法
     */
    private static int buildHash (String str) {
        int p = 16777619;
        int hash = (int) 2166136261L;
        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;
        return Math.abs(hash);
    }

    public static void main (String[] args) {

        String[] node = new String[]{
                "127.0.0.1", "127.0.0.2", "127.0.0.3", "127.0.0.4", "127.0.0.5",
                "127.0.0.6", "127.0.0.7", "127.0.0.8", "127.0.0.9", "127.0.0.10",
        };

        for (int i = 0; i < node.length; i++) {
            String value = node[i];
            System.out.println(value + "匹配到的节点是：" + getService(value));
        }

        System.out.println("-------------------------------------------------");
        String addService = "192.168.0.6";
        addService(addService);
        System.out.println("添加一个真实节点 " + addService);
        for (int i = 0; i < node.length; i++) {
            String value = node[i];
            System.out.println(value + "匹配到的节点是：" + getService(value));
        }

        System.out.println("-------------------------------------------------");
        String deleteService = "192.168.0.1";
        deleteService(deleteService);
        System.out.println("删除一个真实节点 " + deleteService);
        for (int i = 0; i < node.length; i++) {
            String value = node[i];
            System.out.println(value + "匹配到的节点是：" + getService(value));
        }
    }
}

运行后控制台打印结果：
127.0.0.1匹配到的节点是：192.168.0.5
127.0.0.2匹配到的节点是：192.168.0.2
127.0.0.3匹配到的节点是：192.168.0.5
127.0.0.4匹配到的节点是：192.168.0.4
127.0.0.5匹配到的节点是：192.168.0.4
127.0.0.6匹配到的节点是：192.168.0.1
127.0.0.7匹配到的节点是：192.168.0.5
127.0.0.8匹配到的节点是：192.168.0.4
127.0.0.9匹配到的节点是：192.168.0.4
127.0.0.10匹配到的节点是：192.168.0.3
-------------------------------------------------
添加一个真实节点 192.168.0.6
127.0.0.1匹配到的节点是：192.168.0.5
127.0.0.2匹配到的节点是：192.168.0.2
127.0.0.3匹配到的节点是：192.168.0.5
127.0.0.4匹配到的节点是：192.168.0.6
127.0.0.5匹配到的节点是：192.168.0.4
127.0.0.6匹配到的节点是：192.168.0.1
127.0.0.7匹配到的节点是：192.168.0.5
127.0.0.8匹配到的节点是：192.168.0.6
127.0.0.9匹配到的节点是：192.168.0.6
127.0.0.10匹配到的节点是：192.168.0.6
-------------------------------------------------
删除一个真实节点 192.168.0.1
127.0.0.1匹配到的节点是：192.168.0.5
127.0.0.2匹配到的节点是：192.168.0.2
127.0.0.3匹配到的节点是：192.168.0.5
127.0.0.4匹配到的节点是：192.168.0.6
127.0.0.5匹配到的节点是：192.168.0.4
127.0.0.6匹配到的节点是：192.168.0.5
127.0.0.7匹配到的节点是：192.168.0.5
127.0.0.8匹配到的节点是：192.168.0.6
127.0.0.9匹配到的节点是：192.168.0.6
127.0.0.10匹配到的节点是：192.168.0.6

Process finished with exit code 0

最后

• 上述代码不能直接用于实际业务中，只是用于demo参考，理解一致性hash设计思想比其实现更重要。
• 虚心学习，共同进步 -_-