一致性hash算法常用于分布式緩存服務，把所有的服務節點進行hash，得到hash環上的位置。添加進服務的數據用同樣的算法進行hash，然后從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));
}
}
}
以上代碼輸出值：
--添加節點 ABC
C
C
A
--添加節點 D
D
C
A
748451404:B
1081611916
1830063320:A
1542566198
3372629518:D
491985806
3864615324:C
3116163920
參考
https://www.cnblogs.com/lpfuture/p/5796398.html
