一致性哈希算法

普通的哈希算法采用简单取模的方式，将缓存服务器进行散列，通常情况下是没有问题的，但是当缓存服务器的个数发生变动时，将会产生较大的影响

如上图所示，之前有4台缓存服务器，当增加1台缓存服务器之后，除数的变化（4 -> 5）导致求模结果变化，所有缓存查询均未命中

即缓存服务器的个数发生变化时，在一段时间内（缓存重建完毕之前），会有大量缓存查询未命中，导致这段时间内的服务整体性能下降特别严重

一致性哈希算法能有效降低服务器个数变化对整体缓存的影响，基本实现原理是将Hash函数的值域空间组织成一个圆环，将服务器节点进行哈希，并将哈希结果映射到圆环上，当有一个写入缓存的请求到来时，使用相同的Hash函数，计算Key的哈希值在圆环上对应的位置，按顺时针方向，将请求定位至离其最近的服务器节点

如下图所见，当增加一台缓存服务器Server5后，Server4和Server5之间的点将被定位至Server5，Server5和Server之间的点依然定位至Server，并且对Server2，Server3和Server4没影响，比起简单的求模哈希，未命中的缓存查询少了很多，整体服务性能不会下降过大

当然在实际使用过程中会在圆环上添加很多虚拟缓存服务器节点，以便缓存分布更加均匀

介绍完原理，我们再来看一下具体实现，以Memcached-java-client为例

如果我们想使用一致性哈希算法，只需要添加pool.setHashingAlg(SockIOPool.CONSISTENT_HASH);这行代码即可

1. import com.danga.MemCached.MemCachedClient;
2. import com.danga.MemCached.SockIOPool;
4. public class Test {
5. public static void main(String[] args) {
6. MemCachedClient client = new MemCachedClient();
8. String[] servers = {"192.168.52.129:9999",
9. "192.168.52.131:9999"};
10. Integer[] weights = {1, 1};
12. SockIOPool pool = SockIOPool.getInstance();
13. pool.setServers(servers);
14. pool.setWeights(weights);
15. pool.setInitConn(5);
16. pool.setMinConn(5);
17. pool.setMaxConn(250);
18. pool.setMaxIdle(1000 * 60 * 60 * 6);
19. pool.setMaintSleep(30);
20. pool.setNagle(false);
21. pool.setSocketTO(3000);
22. pool.setSocketConnectTO(0);
23. pool.setHashingAlg(SockIOPool.CONSISTENT_HASH);
24. pool.initialize();
26. client.set("test", "This is a test String");
27. String test = (String) client.get("test");
29. System.out.println(test);
30. }
31. }

来看下实际效果

1. sean@ubuntu1:~$ telnet 192.168.52.131 9999
2. Trying 192.168.52.131...
3. Connected to 192.168.52.131.
4. Escape character is '^]'.
5. get test
6. END
8. sean1@ubuntu2:~$ telnet 192.168.52.129 9999
9. Trying 192.168.52.129...
10. Connected to 192.168.52.129.
11. Escape character is '^]'.
12. get test
13. VALUE test 32 21
14. This is a test String
15. END

先从SockIOPool的初始化开始

1. public void initialize() {
2. ......
3. if (this.hashingAlg == 3)
4. populateConsistentBuckets();
5. else
6. populateBuckets();
7. ......
8. }

构建一致性哈希算法中的整个圆环，当然从具体实现上来看只是构建虚拟节点的集合

1. private void populateConsistentBuckets(){
2. this.consistentBuckets = new TreeMap();
3. MessageDigest localMessageDigest = (MessageDigest)MD5.get();
5. // 获得总权重
6. // 如果指定了每个服务器的权重，则其和值为总权重
7. // 否则每个服务器权重为1，总权重为服务器个数
8. if ((this.totalWeight.intValue() <= 0) && (this.weights != null))
9. for (i = 0; i < this.weights.length; ++i){
10. SchoonerSockIOPool localSchoonerSockIOPool = this;
11. (localSchoonerSockIOPool.totalWeight = Integer.valueOf(localSchoonerSockIOPool.totalWeight.intValue()
12. + ((this.weights[i] == null) ? 1 : this.weights[i].intValue())));
13. }
14. else if (this.weights == null)
15. this.totalWeight = Integer.valueOf(this.servers.length);
17. // 循环遍历每一个服务器以便创建其虚拟节点
18. for (int i = 0; i < this.servers.length; ++i){
19. int j = 1;
20. if ((this.weights != null) && (this.weights[i] != null))
21. j = this.weights[i].intValue();
22. // 每个服务器的虚拟节点个数需参照该服务器的权重
23. double d = Math.floor(40 * this.servers.length * j / this.totalWeight.intValue());
24. long l = 0L;
25. // 循环构建每一个节点
26. while (l < d){
27. byte[] arrayOfByte = localMessageDigest.digest(this.servers[i] + "-" + l.getBytes());
28. for (int k = 0; k < 4; ++k){
29. Long localLong = Long.valueOf((arrayOfByte[(3 + k * 4)] & 0xFF) << 24
30. | (arrayOfByte[(2 + k * 4)] & 0xFF) << 16
31. | (arrayOfByte[(1 + k * 4)] & 0xFF) << 8
32. | arrayOfByte[(0 + k * 4)] & 0xFF);
33. // 将每个虚拟节点添加到圆环中
34. this.consistentBuckets.put(localLong, this.servers[i]);
35. }
36. l += 1L;
37. }
38. Object localObject;
39. // 构建socket工厂类
40. if (this.authInfo != null)
41. localObject = new AuthSchoonerSockIOFactory(this.servers[i], this.isTcp, this.bufferSize,
42. this.socketTO, this.socketConnectTO, this.nagle, this.authInfo);
43. else
44. localObject = new SchoonerSockIOFactory(this.servers[i], this.isTcp, this.bufferSize,
45. this.socketTO, this.socketConnectTO, this.nagle);
46. // 使用socket工厂类创建连接池
47. GenericObjectPool localGenericObjectPool = new GenericObjectPool((PoolableObjectFactory)localObject,
48. this.maxConn, 1, this.maxIdle, this.maxConn);
49. ((SchoonerSockIOFactory)localObject).setSockets(localGenericObjectPool);
50. // 每个服务器都有自己的连接池
51. this.socketPool.put(this.servers[i], localGenericObjectPool);
52. }
53. }

MemcachedClient的初始化方法，通过该方法可确定Client的具体实现类为AscIIUDPClient

1. public MemCachedClient() {
2. this(null, true, false);
3. }
5. public MemCachedClient(String paramString, boolean paramBoolean1,
6. boolean paramBoolean2) {
7. this.BLAND_DATA_SIZE = " ".getBytes();
8. if (paramBoolean2)
9. this.client = new BinaryClient(paramString);
10. else
11. this.client = new AscIIUDPClient(paramString);
12. }

当发送一个添加请求时，本质还是通过调用set方法实现的

1. public boolean add(String paramString, Object paramObject) {
2. return set("add", paramString, paramObject, null, null,
3. Long.valueOf(0L));
4. }
6. // paramInteger的值为null
7. private boolean set(String paramString1, String paramString2,
8. Object paramObject, Date paramDate, Integer paramInteger,
9. Long paramLong) {
10. ......
11. SchoonerSockIO localSchoonerSockIO = this.pool.getSock(paramString2,
12. paramInteger);
13. ......
14. }

服务器的查找过程如下

1. public final SchoonerSockIO getSock(String paramString, Integer paramInteger) {
2. ......
3. // 计算Key的哈希值，并根据该哈希值得到对应的服务器节点哈希值
4. long l = getBucket(paramString, paramInteger);
5. // 根据服务器节点哈希值得到对应的服务器
6. String str1 = (this.hashingAlg == 3) ? (String) this.consistentBuckets
7. .get(Long.valueOf(l)) : (String) this.buckets.get((int) l);
8. while (!(((Set) localObject).isEmpty())) {
9. // 从服务器连接池中获取到特定服务器的连接
10. SchoonerSockIO localSchoonerSockIO = getConnection(str1);
11. ......
12. }

首选根据Key值计算出其哈希值（getHash），然后根据得到的哈希值确定其在圆环上对应的服务器节点（findPointFor）

1. // paramInteger的值为null
2. private final long getBucket(String paramString, Integer paramInteger) {
3. long l1 = getHash(paramString, paramInteger);
4. if (this.hashingAlg == 3)
5. return findPointFor(Long.valueOf(l1)).longValue();
6. long l2 = l1 % this.buckets.size();
7. if (l2 < 0L)
8. l2 *= -1L;
9. return l2;
10. }

Key的哈希值计算过程如下，和populateConsistentBuckets方法中用来生成服务器虚拟节点哈希值的算法是一样的

1. // paramInteger的值为null
2. private final long getHash(String paramString, Integer paramInteger) {
3. if (paramInteger != null) {
4. if (this.hashingAlg == 3)
5. return (paramInteger.longValue() & 0xFFFFFFFF);
6. return paramInteger.longValue();
7. }
8. switch (this.hashingAlg) {
9. case 0:
10. return paramString.hashCode();
11. case 1:
12. return origCompatHashingAlg(paramString);
13. case 2:
14. return newCompatHashingAlg(paramString);
15. case 3:
16. return md5HashingAlg(paramString);
17. }
18. this.hashingAlg = 0;
19. return paramString.hashCode();
20. }
22. private static long md5HashingAlg(String paramString) {
23. MessageDigest localMessageDigest = (MessageDigest) MD5.get();
24. localMessageDigest.reset();
25. localMessageDigest.update(paramString.getBytes());
26. byte[] arrayOfByte = localMessageDigest.digest();
27. long l = (arrayOfByte[3] & 0xFF) << 24 | (arrayOfByte[2] & 0xFF) << 16
28. | (arrayOfByte[1] & 0xFF) << 8 | arrayOfByte[0] & 0xFF;
29. return l;
30. }

在圆环上查找Key的哈希值对应的服务器节点哈希值

参照populateConsistentBuckets中的代码，所有虚拟节点被存放在一个TreeMap中，所以这里可以使用tailMap方法获得大于等于Key哈希值的子树，然后获取该树中最小值即可

1. private final Long findPointFor(Long paramLong) {
2. SortedMap localSortedMap = this.consistentBuckets.tailMap(paramLong);
3. return ((localSortedMap.isEmpty()) ? (Long) this.consistentBuckets
4. .firstKey() : (Long) localSortedMap.firstKey());
5. }

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.youkuaiyun.com/a19881029/article/details/52766698