一致性hash环算法java实现

用途：

用于分布式系统中多个服务器集群，当增加减少节点时，使用该hash环算法，可减少数据因节点变动，出现大量命中失败问题，redis集群就是通过hash环思想实现的。

解释：
一致性哈希环，分散化实体项的节点位置选择，减少因为节点的变更导致的其上所属实体项的迁移。

hash工具类：

package com.jintao.example.consistenthash;

/**
 * @author jinjueYang
 * @description
 * @date 2019/10/10 11:08
 */
public class FNV1_32Hash {

    /**
     * 改进的32位FNV算法1
     *
     * @param data 字符串
     * @return int值
     */
    public static int FNVHash1(String data) {
        final int p = 16777619;
        int hash = (int) 2166136261L;
        for (int i = 0; i < data.length(); i++)
            hash = (hash ^ data.charAt(i)) * p;
        hash += hash << 13;
        hash ^= hash >> 7;
        hash += hash << 3;
        hash ^= hash >> 17;
        hash += hash << 5;
        return hash;
    }

    public static String FNVHash1Str(String data) {
        return Integer.toString(FNVHash1(data));
    }
}

hash环算法实现：

package com.jintao.example.consistenthash;

import java.util.*;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.stream.Collectors;

/**
 * @author jinjueYang
 * @description 基于fnv1_32实现一致性hash环
 * @date 2019/10/10 12:35
 */
public class MyConsistetentHashRing {

    //默认分配虚拟节点100个
    private static final Integer virtualNodeCount = 100;
    private static final String originHashStr = "-OriginHashStr-";
    //物理节点和虚拟节点对应关系map
    private Map<String, List<Integer>> realToVirtualNodeMap = new HashMap<>();
    //虚拟节点对应物理节点Map,使用TreeMap方便快速查找和插入(底层实现是红黑树)
    private SortedMap<Integer, String> virtualNodeMap = new TreeMap<>();
    /**
     * Synchronization 锁同步.
     */
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private final Lock readLock = readWriteLock.readLock();
    private final Lock writeLock = readWriteLock.writeLock();

    public MyConsistetentHashRing(Set<String> nodes) {
        nodes.forEach(node -> {
            addNode(node);
        });
    }

    public void addNode(String node) {
        writeLock.lock();
        int i = 0;//自增值，用于生成不同字符串hash使用，没有实际意义
        int j = 0;//虚拟节点个数
        List<Integer> virtualNodeList = new ArrayList<>();
        try {
            while (j < virtualNodeCount) {
                //注意这里的hash可能会冲突，所以下面使用i++，来不断生成hash，以达到生成100个虚拟节点
                Integer hash = FNV1_32Hash.FNVHash1(node + originHashStr + (i++));
                if (!virtualNodeMap.containsKey(hash)) {
                    //如果虚拟节点中不存在该hash值，那么就加入进来
                    virtualNodeList.add(hash);
                    realToVirtualNodeMap.put(node, virtualNodeList);
                    virtualNodeMap.put(hash, node);
                    j++;
                } else {
                    //如果包含，说明hash冲突，那么就继续生成hash
                    i++;
                }
            }
        } finally {
            writeLock.unlock();
        }
    }

    public String getNode(String item) {
        readLock.lock();
        try {
            Integer hash = FNV1_32Hash.FNVHash1(item);
            //如果不包含该节点
            if (!virtualNodeMap.containsKey(hash)) {
                //先查找当前虚拟节点hash环中离该hash最近的节点
                // 将哈希环定位到大于此key的首个位置
                SortedMap<Integer, String> tailMap = virtualNodeMap.tailMap(hash);
                // 并得到第一个大于此key的项目的key,也就是距离最近的key
                hash = tailMap.isEmpty() ? virtualNodeMap.firstKey() : tailMap.firstKey();
            }
            return virtualNodeMap.get(hash);
        } finally {
            readLock.unlock();
        }
    }

    /**
     * 节点实体类
     */
    private static class Node {
        String nodeName;

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

        public String getNodeName() {
            return nodeName;
        }

        public void setNodeName(String nodeName) {
            this.nodeName = nodeName;
        }
    }

    public static void main(String[] args) {
        //测试分布的均匀性
        MyConsistetentHashRing consistentHashRing = new MyConsistetentHashRing(new HashSet<>(Arrays.asList("192.168.10.1", "192.168.10.2", "192.168.10.3")));
        List<Node> nodes = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            String node = consistentHashRing.getNode("adewofjeiwfi" + i);
            nodes.add(new Node(node));
//            System.out.println(node);
        }
        nodes.stream().collect(Collectors.groupingBy(Node::getNodeName))
                .forEach((key, value) -> System.out.println(key + "->" + value.size()));
    }
}

运行结果：

192.168.10.1->3290
192.168.10.3->3144
192.168.10.2->3566

可以看到运行结果里面三个物理节点在10000条测试数据中命中的概率大致相同，分别是3290,3144,3566。

调增参数虚拟节点：virtualNodeCount =10000继续进行测试，运行结果：

192.168.10.1->3348
192.168.10.3->3325
192.168.10.2->3327

这块可以根据自己需求调整，virtualNodeCount的大小。