Java代码
public class ConsistentHash {
private final HashFunction hashFunction;
private final int numberOfReplicas;
private final SortedMap circle = new TreeMap();
public ConsistentHash(HashFunction hashFunction, int numberOfReplicas, Collection nodes) {
this .hashFunction = hashFunction;
this .numberOfReplicas = numberOfReplicas;
for (T node : nodes) {
add(node);
}
}
public void add(T node) {
for (int i = 0; i < numberOfReplicas; i++) {
circle .put(hashFunction .hash(node.toString() + i), node);
}
}
public void remove(T node) {
for (int i = 0; i < numberOfReplicas; i++) {
circle .remove(hashFunction .hash(node.toString() + i));
}
}
public T get(Object key) {
if (circle .isEmpty()) {
return null ;
}
int hash = hashFunction .hash(key);
// System.out.println("hash---: " + hash);
if (!circle .containsKey(hash)) {
SortedMap tailMap = circle .tailMap(hash);
hash = tailMap.isEmpty() ? circle .firstKey() : tailMap.firstKey();
}
// System.out.println("hash---: " + hash);
return circle .get(hash);
}
static class HashFunction {
int hash(Object key) {
//md5加密后,hashcode
return Md5Encrypt.md5(key.toString()).hashCode();
}
}
public static void main(String [] args) {
HashSet< String> set = new HashSet< String>();
set.add( "A" );
set.add( "B" );
set.add( "C" );
set.add( "D" );
Map< String, Integer> map = new HashMap< String, Integer>();
ConsistentHash< String> consistentHash = new ConsistentHash( new HashFunction(), 1000, set);
int count = 10000;
for (int i = 0; i < count; i++) {
String key = consistentHash.get(i);
if (map.containsKey(key)) {
map.put(consistentHash.get(i), map.get(key) + 1);
} else {
map.put(consistentHash.get(i), 1);
}
// System.out.println(key);
}
showServer(map);
map.clear();
consistentHash.remove( "A" );
System. out .println("------- remove A" );
for (int i = 0; i < count; i++) {
String key = consistentHash.get(i);
if (map.containsKey(key)) {
map.put(consistentHash.get(i), map.get(key) + 1);
} else {
map.put(consistentHash.get(i), 1);
}
// System.out.println(key);
}
showServer(map);
map.clear();
consistentHash.add( "E" );
System. out .println("------- add E" );
for (int i = 0; i < count; i++) {
String key = consistentHash.get(i);
if (map.containsKey(key)) {
map.put(consistentHash.get(i), map.get(key) + 1);
} else {
map.put(consistentHash.get(i), 1);
}
// System.out.println(key);
}
showServer(map);
map.clear();
consistentHash.add( "F" );
System. out .println("------- add F服务器 业务量加倍" );
count = count * 2;
for (int i = 0; i < count; i++) {
String key = consistentHash.get(i);
if (map.containsKey(key)) {
map.put(consistentHash.get(i), map.get(key) + 1);
} else {
map.put(consistentHash.get(i), 1);
}
// System.out.println(key);
}
showServer(map);
}
public static void showServer(Map map) {
for (Entry m : map.entrySet()) {
System. out .println("服务器 " + m.getKey() + "----" + m.getValue() + "个" );
}
}
}
运行结果 :
服务器 D----2630个
服务器 A----2453个
服务器 B----2340个
服务器 C----2577个
------- remove A服务器
服务器 D----3489个
服务器 B----3107个
服务器 C----3404个
------- add E服务器
服务器 D----2572个
服务器 E----2469个
服务器 B----2361个
服务器 C----2598个
------- add F服务器 业务量加倍
服务器 D----4011个
服务器 E----4050个
服务器 F----3848个
服务器 B----3956个
服务器 C----4135个
numberOfReplicas 是虚拟服务器系数, 越大分布越均衡,但越大,在初始化和变更的时候效率差一点。 测试中,设置200基本就均衡了。