记录一致性hash的java实现

一致性hash通常用在客户端的负载均衡策略，目的就是在变更服务器数量时，能尽量保证命中率。这样就不会造成缓存雪崩的问题。下列代码就是通过模拟正常hash和一致性hash的比对进行。

对于正常的hash而言，当我们存入K,V键值对时，我们只需要hash(K) % size，然后把结果映射到对应服务器即可。这种方式对于服务器负载均衡而言是很好的，经过测试每台服务器的压力都会平均。但是在扩展服务器后，可能就会出现问题，造成大量K不命中，从而重新往数据库查数据，增加了数据库压力。

对于一致性hash，需要有足够多的主机，才能让映射足够平均。解决方案往往是使用虚拟节点，这里我使用MD5来散列服务器计算hash值。

代码如下：

public abstract class BaseCache {

    private static final int BASE = 0x7fffffff;

    private HashMap<String, HashMap<String, String>> CACHE = new HashMap<>();//通过ip地址查找对应的缓存
    private HashMap<String, Integer> LOAD = new HashMap<>();
    private int count;
    private int notHitCount;

    /**
     * 基本的hash计算
     * @param name
     * @return
     */
    public int hash(String name){
        int hash = DigestUtils.md5Hex(name).hashCode();//使用MD5计算，然后获得hashCode。
        hash = (hash ^ (hash >>> 16)) & BASE;//对hash进行spread，同时保证是正数。
        return hash;
    }

    public abstract String getTargetHost(int hash);//根据策略获取指定主机

    public void putCache(String key, String value){
        String targetHost = getTargetHost(hash(key));
        if(targetHost != null){
            HashMap<String, String> map = CACHE.getOrDefault(targetHost, new HashMap<>());
            map.put(key, value);
            CACHE.putIfAbsent(targetHost, map);
            Integer initialValue = LOAD.getOrDefault(targetHost, 0);
            LOAD.putIfAbsent(targetHost, initialValue);
        }
    }

    public String getCache(String key){
        String targetHost = getTargetHost(hash(key));
        if(targetHost != null){
            HashMap<String, String> cache = CACHE.get(targetHost);
            Integer load = LOAD.get(targetHost);
            count++;//查询+1
            if(cache == null){
                cache = CACHE.getOrDefault(targetHost, new HashMap<>());
                CACHE.putIfAbsent(targetHost, cache);
            }
            if(load == null){
                LOAD.put(targetHost, 1);
            }else{
                LOAD.put(targetHost, load + 1);
            }
            String value = cache.get(key);
            if(value == null){
                //未命中
                notHitCount++;
                return null;
            }
            return value;
        }
        throw new RuntimeException("传入为null");
    }

    public void printMetric(){
        double rate = 0;
        if(count > 0){
            rate = 1 - (1.0 * notHitCount / count);
            System.out.println("命中率：" + rate);
            LOAD.forEach((k, v)->{
                System.out.println("host:" + k+", load:" + (1.0 * v / count));
            });
        }
    }

    public void resetCount(){
        count = notHitCount = 0;
        LOAD.clear();
    }

}

后面为其实现类，分别是简单hash的实现类以及一致性hash的实现类。

public class SimpleHashCache extends BaseCache {

    private List<String> hosts;

    public SimpleHashCache(List<String> hosts) {
        this.hosts = hosts;
    }

    public void addNewHost(String host){
        hosts.add(host);
    }

    @Override
    public String getTargetHost(int hash) {
        return hosts.get(hash % hosts.size());
    }

}

public class ConsistentHashCache extends BaseCache {

    private List<String> hosts;
    private TreeMap<Integer, String> hashHostsMap = new TreeMap<>();

    public ConsistentHashCache(List<String> hosts) {
        this.hosts = hosts;
        hosts.forEach(host -> {
            hashHostsMap.put(hash(host), host);
        });
    }

    public void addNewHost(String host){
        hosts.add(host);
        hashHostsMap.put(hash(host), host);
    }

    @Override
    public String getTargetHost(int hash) {
        //一致性hash映射，这里是非虚拟节点
        Set<Map.Entry<Integer, String>> entries = hashHostsMap.entrySet();
        Integer selectKey = null;
        for(Map.Entry<Integer, String> entry : entries){
            Integer key = entry.getKey();
            if(selectKey == null)selectKey = key;
            if(hash < key){
                selectKey = key;
                break;
            }
        }
        return hashHostsMap.get(selectKey);
    }
}

我分别插入10W个数据，然后使用get方法。
结果如下：
当默认为10台服务器，此时加入一台新服务器，普通hash和一致性hash的命中率差别很大。简单hash只有8%的命中率，而一致性hash依然有85%命中率。

简单hash：

一致性hash：