聊聊一致性Hash算法代码实现-一致性hash算法

什么是一致性hash

一致性哈希算法(Consistent Hashing Algorithm)是一种分布式算法，常用于负载均衡。Memcached client也选择这种算法，解决将key-value均匀分配到众多Memcached server上的问题。它可以取代传统的取模操作，解决了取模操作无法应对增删Memcached Server的问题(增删server会导致同一个key,在get操作时分配不到数据真正存储的server，命中率会急剧下降)。

一致性哈希将整个哈希值空间组织成一个虚拟的圆环，如假设某哈希函数H的值空间为0-2^32-1（即哈希值是一个32位无符号整形）。

整个空间按顺时针方向组织，0和232-1在零点中方向重合。

一致性hash有什么用

一致性hash算法常用于分布式缓存服务，把所有的服务节点进行hash，得到hash环上的位置。

添加进服务的数据用同样的算法进行hash，然后从hash环上取得大于该hash值的第一个节点，如果没有大于该值的节点，那么就取整个环的第一个节点。

存在问题

在节点太少的情况，有可能存在hash偏移。就是节点负载不均衡，大量数据落在其中一个节点上面。

解决办法是，在环上面虚拟出足够多的节点，虚拟的节点和实际节点做对应。

java代码实现

package com.hj.lock.alg;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*;

public class ConsistentHash<T> {
    /**
     * Hash计算对象，用于自定义hash算法
     */
    HashFunc hashFunc;
    /**
     * 复制的节点个数
     */
    private final int numberOfReplicas;
    /**
     * 一致性Hash环
     */
    private final TreeMap<Long, T> hashCircle = new TreeMap<>();

    /**
     * 构造，使用Java默认的Hash算法
     *
     * @param numberOfReplicas 复制的节点个数，增加每个节点的复制节点有利于负载均衡
     * @param
    public ConsistentHash(int numberOfReplicas, Collection<T> nodes){
        this.numberOfReplicas = numberOfReplicas;
        this.hashFunc = ConsistentHash::md5HashingAlg;
        //初始化节点
        nodes.forEach(node -> add(node));
    }

    /**
     * 增加节点<br>
     * 每增加一个节点，就会在闭环上增加给定复制节点数<br>
     * 例如复制节点数是2，则每调用此方法一次，增加两个虚拟节点，这两个节点指向同一Node
     * 由于hash算法会调用node的toString方法，故按照toString去重
     *
     * @param
    public void add(T node){
        for (int i = 0; i < numberOfReplicas; i++) {
            hashCircle.put(hashFunc.hash(node.toString() + i), node);
        }
    }

    /**
     * 移除节点的同时移除相应的虚拟节点
     *
     * @param
    public void remove(T node){
        for (int i = 0; i < numberOfReplicas; i++) {
            hashCircle.remove(hashFunc.hash(node.toString() + i));
        }
    }

    /**
     * 获得一个最近的顺时针节点
     *
     * @param key 为给定键取Hash，取得顺时针方向上最近的一个虚拟节点对应的实际节点
     * @return
    public T get(Object key){
        if (hashCircle.isEmpty()) {
            return null;
        }
        long hash = hashFunc.hash(key);
        hash = nextHash(hash);
        //正好命中
        return hashCircle.get(hash);
    }

    public Long nextHash(Long hash){
        if (!hashCircle.containsKey(hash)) {
            Long next = hashCircle.higherKey(hash + 1);//返回下一个hash值
            hash = next == null ? hashCircle.firstKey() : next;
        }
        return hash;
    }

    /**
     * 使用MD5算法
     *
     * @param key
     * @return
    private static long md5HashingAlg(Object key){
        MessageDigest md5 = null;
        try {
            md5 = MessageDigest.getInstance("MD5");
            md5.reset();
            String str = key.toString();
            md5.update(str.getBytes());
            byte[] bKey = md5.digest();
            long res = ((long) (bKey[3] & 0xFF) << 24) | ((long) (bKey[2] & 0xFF) << 16) | ((long) (bKey[1] & 0xFF) << 8) | (long) (bKey[0] & 0xFF);
            return res;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return 0l;
    }

    /**
     * 使用FNV1hash算法
     *
     * @param key
     * @return
    private static long fnv1HashingAlg(Object key){
        final int p = 16777619;
        int hash = (int) 2166136261L;
        String str = key.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;
        return hash;
    }

    /**
     * Hash算法对象，用于自定义hash算法
     */
    public interface HashFunc {
        public Long hash(Object key);
    }

    public static void main(String[] args){
        List<String> nodes = new ArrayList<>();
        System.out.println("--添加节点 ABC");
        nodes.add("A");
        nodes.add("B");
        nodes.add("C");
        ConsistentHash<String> chash = new ConsistentHash(1, nodes);
        System.out.println(chash.get("test1"));
        System.out.println(chash.get("aest2"));
        System.out.println(chash.get("dest3"));
        System.out.println("--添加节点 D");
        chash.add("D");
        System.out.println(chash.get("test1"));
        System.out.println(chash.get("aest2"));
        System.out.println(chash.get("dest3"));

        for (Iterator<Map.Entry<Long, String>> it = chash.hashCircle.entrySet().iterator(); it.hasNext(); ) {
            Map.Entry<Long, String> entry = it.next();
            Long k = entry.getKey();
            System.out.println(k + ":" + entry.getValue());
            System.out.println(Math.abs(chash.nextHash(k + 1) - k));
        }
    }

}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.

以上代码输出值：

--添加节点 ABC
C
C
A
--添加节点 D
D
C
A
748451404:B
1081611916
1830063320:A
1542566198
3372629518:D
491985806
3864615324:C
31161639201.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

参考

https://www.cnblogs.com/lpfuture/p/5796398.html