week-5-part1 java 实现一致性 hash 算法



1. public class ConsistentHash<T> {    

2.     

3.        private final HashFunction hashFunction;    

4.        private final int numberOfReplicas;    

5.        private final SortedMap<Integer, T> circle = new TreeMap<Integer, T>();    

6.     

7.        public ConsistentHash(HashFunction hashFunction, int numberOfReplicas, Collection<T> nodes) {    

8.              this .hashFunction = hashFunction;    

9.              this .numberOfReplicas = numberOfReplicas;    

10.     

11.              for (T node : nodes) {    

12.                   add(node);    

13.             }    

14.       }    

15.     

16.        public void add(T node) {    

17.              for (int i = 0; i < numberOfReplicas; i++) {    

18.                    circle .put(hashFunction .hash(node.toString() + i), node);    

19.             }    

20.       }    

21.     

22.        public void remove(T node) {    

23.              for (int i = 0; i < numberOfReplicas; i++) {    

24.                    circle .remove(hashFunction .hash(node.toString() + i));    

25.             }    

26.       }    

27.     

28.        public T get(Object key) {    

29.              if (circle .isEmpty()) {    

30.                    return null ;    

31.             }    

32.              int hash = hashFunction .hash(key);    

33.              // System.out.println("hash---: " + hash);    

34.              if (!circle .containsKey(hash)) {    

35.                   SortedMap<Integer, T> tailMap = circle .tailMap(hash);    

36.                   hash = tailMap.isEmpty() ? circle .firstKey() : tailMap.firstKey();    

37.             }    

38.              // System.out.println("hash---: " + hash);    

39.              return circle .get(hash);    

40.       }    

41.     

42.        static class HashFunction {    

43.              int hash(Object key) {  

44.                    //md5加密后，hashcode  

45.                    return Md5Encrypt.md5(key.toString()).hashCode();    

46.             }    

47.       }    

48.     

49.        public static void main(String [] args) {    

50.             HashSet< String> set = new HashSet< String>();    

51.             set.add( "A" );    

52.             set.add( "B" );    

53.             set.add( "C" );    

54.             set.add( "D" );    

55.     

56.             Map< String, Integer> map = new HashMap< String, Integer>();    

57.     

58.             ConsistentHash< String> consistentHash = new ConsistentHash<String>( new HashFunction(), 1000, set);    

59.     

60.              int count = 10000;    

61.     

62.              for (int i = 0; i < count; i++) {    

63.                    String key = consistentHash.get(i);    

64.                    if (map.containsKey(key)) {    

65.                         map.put(consistentHash.get(i), map.get(key) + 1);    

66.                   } else {    

67.                         map.put(consistentHash.get(i), 1);    

68.                   }    

69.                    // System.out.println(key);    

70.             }    

71.     

72.              showServer(map);    

73.             map.clear();    

74.             consistentHash.remove( "A" );    

75.     

76.             System. out .println("------- remove A" );    

77.     

78.              for (int i = 0; i < count; i++) {    

79.                    String key = consistentHash.get(i);    

80.                    if (map.containsKey(key)) {    

81.                         map.put(consistentHash.get(i), map.get(key) + 1);    

82.                   } else {    

83.                         map.put(consistentHash.get(i), 1);    

84.                   }    

85.                    // System.out.println(key);    

86.             }    

87.     

88.              showServer(map);    

89.             map.clear();    

90.             consistentHash.add( "E" );    

91.             System. out .println("------- add E" );    

92.     

93.              for (int i = 0; i < count; i++) {    

94.                    String key = consistentHash.get(i);    

95.                    if (map.containsKey(key)) {    

96.                         map.put(consistentHash.get(i), map.get(key) + 1);    

97.                   } else {    

98.                         map.put(consistentHash.get(i), 1);    

99.                   }    

100.                    // System.out.println(key);    

101.             }    

102.     

103.              showServer(map);    

104.             map.clear();    

105.     

106.             consistentHash.add( "F" );    

107.             System. out .println("------- add F服务器  业务量加倍" );    

108.             count = count * 2;    

109.              for (int i = 0; i < count; i++) {    

110.                   String key = consistentHash.get(i);    

111.                    if (map.containsKey(key)) {    

112.                         map.put(consistentHash.get(i), map.get(key) + 1);    

113.                   } else {    

114.                         map.put(consistentHash.get(i), 1);    

115.                   }    

116.                    // System.out.println(key);    

117.             }    

118.     

119.              showServer(map);    

120.     

121.       }    

122.     

123.        public static void showServer(Map<String , Integer> map) {    

124.              for (Entry<String, Integer> m : map.entrySet()) {    

125.                   System. out .println("服务器 " + m.getKey() + "----" + m.getValue() + "个" );    

126.             }    

127.       }    

128.     

129. }