【轉載】對一致性Hash演算法，Java程式碼實現的深入研究

/**
 * String的hashCode()方法運算結果檢視
 * @author 五月的倉頡 http://www.cnblogs.com/xrq730/
 *
 */
public class StringHashCodeTest
{
    public static void main(String[] args)
    {
        System.out.println("192.168.0.0:111的雜湊值：" + "192.168.0.0:1111".hashCode());
        System.out.println("192.168.0.1:111的雜湊值：" + "192.168.0.1:1111".hashCode());
        System.out.println("192.168.0.2:111的雜湊值：" + "192.168.0.2:1111".hashCode());
        System.out.println("192.168.0.3:111的雜湊值：" + "192.168.0.3:1111".hashCode());
        System.out.println("192.168.0.4:111的雜湊值：" + "192.168.0.4:1111".hashCode());
    }
}

192.168.0.0:111的雜湊值：1845870087
192.168.0.1:111的雜湊值：1874499238
192.168.0.2:111的雜湊值：1903128389
192.168.0.3:111的雜湊值：1931757540
192.168.0.4:111的雜湊值：1960386691

 1 /**
 2  * 不帶虛擬節點的一致性Hash演算法
 3  * @author 五月的倉頡http://www.cnblogs.com/xrq730/
 4  *
 5  */
 6 public class ConsistentHashingWithoutVirtualNode
 7 {
 8     /**
 9      * 待新增入Hash環的伺服器列表
10      */
11     private static String[] servers = {"192.168.0.0:111", "192.168.0.1:111", "192.168.0.2:111",
12             "192.168.0.3:111", "192.168.0.4:111"};
13     
14     /**
15      * key表示伺服器的hash值，value表示伺服器的名稱
16      */
17     private static SortedMap<Integer, String> sortedMap = 
18             new TreeMap<Integer, String>();
19     
20     /**
21      * 程式初始化，將所有的伺服器放入sortedMap中
22      */
23     static
24     {
25         for (int i = 0; i < servers.length; i++)
26         {
27             int hash = getHash(servers[i]);
28             System.out.println("[" + servers[i] + "]加入集合中, 其Hash值為" + hash);
29             sortedMap.put(hash, servers[i]);
30         }
31         System.out.println();
32     }
33     
34     /**
35      * 使用FNV1_32_HASH演算法計算伺服器的Hash值,這裡不使用重寫hashCode的方法，最終效果沒區別 
36      */
37     private static int getHash(String str)
38     {
39         final int p = 16777619;
40         int hash = (int)2166136261L;
41         for (int i = 0; i < str.length(); i++)
42             hash = (hash ^ str.charAt(i)) * p;
43         hash += hash << 13;
44         hash ^= hash >> 7;
45         hash += hash << 3;
46         hash ^= hash >> 17;
47         hash += hash << 5;
48         
49         // 如果算出來的值為負數則取其絕對值
50         if (hash < 0)
51             hash = Math.abs(hash);
52         return hash;
53     }
54     
55     /**
56      * 得到應當路由到的結點
57      */
58     private static String getServer(String node)
59     {
60         // 得到帶路由的結點的Hash值
61         int hash = getHash(node);
62         // 得到大於該Hash值的所有Map
63         SortedMap<Integer, String> subMap = 
64                 sortedMap.tailMap(hash);
65         // 第一個Key就是順時針過去離node最近的那個結點
66         Integer i = subMap.firstKey();
67         // 返回對應的伺服器名稱
68         return subMap.get(i);
69     }
70     
71     public static void main(String[] args)
72     {
73         String[] nodes = {"127.0.0.1:1111", "221.226.0.1:2222", "10.211.0.1:3333"};
74         for (int i = 0; i < nodes.length; i++)
75             System.out.println("[" + nodes[i] + "]的hash值為" + 
76                     getHash(nodes[i]) + ", 被路由到結點[" + getServer(nodes[i]) + "]");
77     }
78 }

[192.168.0.0:111]加入集合中, 其Hash值為575774686
[192.168.0.1:111]加入集合中, 其Hash值為8518713
[192.168.0.2:111]加入集合中, 其Hash值為1361847097
[192.168.0.3:111]加入集合中, 其Hash值為1171828661
[192.168.0.4:111]加入集合中, 其Hash值為1764547046

[127.0.0.1:1111]的hash值為380278925, 被路由到結點[192.168.0.0:111]
[221.226.0.1:2222]的hash值為1493545632, 被路由到結點[192.168.0.4:111]
[10.211.0.1:3333]的hash值為1393836017, 被路由到結點[192.168.0.4:111]

 1 /**
 2  * 帶虛擬節點的一致性Hash演算法
 3  * @author 五月的倉頡 http://www.cnblogs.com/xrq730/
 4  */
 5 public class ConsistentHashingWithVirtualNode
 6 {
 7     /**
 8      * 待新增入Hash環的伺服器列表
 9      */
10     private static String[] servers = {"192.168.0.0:111", "192.168.0.1:111", "192.168.0.2:111",
11             "192.168.0.3:111", "192.168.0.4:111"};
12     
13     /**
14      * 真實結點列表,考慮到伺服器上線、下線的場景，即新增、刪除的場景會比較頻繁，這裡使用LinkedList會更好
15      */
16     private static List<String> realNodes = new LinkedList<String>();
17     
18     /**
19      * 虛擬節點，key表示虛擬節點的hash值，value表示虛擬節點的名稱
20      */
21     private static SortedMap<Integer, String> virtualNodes = 
22             new TreeMap<Integer, String>();
23     
24     /**
25      * 虛擬節點的數目，這裡寫死，為了演示需要，一個真實結點對應5個虛擬節點
26      */
27     private static final int VIRTUAL_NODES = 5;
28     
29     static
30     {
31         // 先把原始的伺服器新增到真實結點列表中
32         for (int i = 0; i < servers.length; i++)
33             realNodes.add(servers[i]);
34         
35         // 再新增虛擬節點，遍歷LinkedList使用foreach迴圈效率會比較高
36         for (String str : realNodes)
37         {
38             for (int i = 0; i < VIRTUAL_NODES; i++)
39             {
40                 String virtualNodeName = str + "&&VN" + String.valueOf(i);
41                 int hash = getHash(virtualNodeName);
42                 System.out.println("虛擬節點[" + virtualNodeName + "]被新增, hash值為" + hash);
43                 virtualNodes.put(hash, virtualNodeName);
44             }
45         }
46         System.out.println();
47     }
48     
49     /**
50      * 使用FNV1_32_HASH演算法計算伺服器的Hash值,這裡不使用重寫hashCode的方法，最終效果沒區別 
51      */
52     private static int getHash(String str)
53     {
54         final int p = 16777619;
55         int hash = (int)2166136261L;
56         for (int i = 0; i < str.length(); i++)
57             hash = (hash ^ str.charAt(i)) * p;
58         hash += hash << 13;
59         hash ^= hash >> 7;
60         hash += hash << 3;
61         hash ^= hash >> 17;
62         hash += hash << 5;
63         
64         // 如果算出來的值為負數則取其絕對值
65         if (hash < 0)
66             hash = Math.abs(hash);
67         return hash;
68     }
69     
70     /**
71      * 得到應當路由到的結點
72      */
73     private static String getServer(String node)
74     {
75         // 得到帶路由的結點的Hash值
76         int hash = getHash(node);
77         // 得到大於該Hash值的所有Map
78         SortedMap<Integer, String> subMap = 
79                 virtualNodes.tailMap(hash);
80         // 第一個Key就是順時針過去離node最近的那個結點
81         Integer i = subMap.firstKey();
82         // 返回對應的虛擬節點名稱，這裡字串稍微擷取一下
83         String virtualNode = subMap.get(i);
84         return virtualNode.substring(0, virtualNode.indexOf("&&"));
85     }
86     
87     public static void main(String[] args)
88     {
89         String[] nodes = {"127.0.0.1:1111", "221.226.0.1:2222", "10.211.0.1:3333"};
90         for (int i = 0; i < nodes.length; i++)
91             System.out.println("[" + nodes[i] + "]的hash值為" + 
92                     getHash(nodes[i]) + ", 被路由到結點[" + getServer(nodes[i]) + "]");
93     }
94 }

虛擬節點[192.168.0.0:111&&VN0]被新增, hash值為1686427075
虛擬節點[192.168.0.0:111&&VN1]被新增, hash值為354859081
虛擬節點[192.168.0.0:111&&VN2]被新增, hash值為1306497370
虛擬節點[192.168.0.0:111&&VN3]被新增, hash值為817889914
虛擬節點[192.168.0.0:111&&VN4]被新增, hash值為396663629
虛擬節點[192.168.0.1:111&&VN0]被新增, hash值為1032739288
虛擬節點[192.168.0.1:111&&VN1]被新增, hash值為707592309
虛擬節點[192.168.0.1:111&&VN2]被新增, hash值為302114528
虛擬節點[192.168.0.1:111&&VN3]被新增, hash值為36526861
虛擬節點[192.168.0.1:111&&VN4]被新增, hash值為848442551
虛擬節點[192.168.0.2:111&&VN0]被新增, hash值為1452694222
虛擬節點[192.168.0.2:111&&VN1]被新增, hash值為2023612840
虛擬節點[192.168.0.2:111&&VN2]被新增, hash值為697907480
虛擬節點[192.168.0.2:111&&VN3]被新增, hash值為790847074
虛擬節點[192.168.0.2:111&&VN4]被新增, hash值為2010506136
虛擬節點[192.168.0.3:111&&VN0]被新增, hash值為891084251
虛擬節點[192.168.0.3:111&&VN1]被新增, hash值為1725031739
虛擬節點[192.168.0.3:111&&VN2]被新增, hash值為1127720370
虛擬節點[192.168.0.3:111&&VN3]被新增, hash值為676720500
虛擬節點[192.168.0.3:111&&VN4]被新增, hash值為2050578780
虛擬節點[192.168.0.4:111&&VN0]被新增, hash值為586921010
虛擬節點[192.168.0.4:111&&VN1]被新增, hash值為184078390
虛擬節點[192.168.0.4:111&&VN2]被新增, hash值為1331645117
虛擬節點[192.168.0.4:111&&VN3]被新增, hash值為918790803
虛擬節點[192.168.0.4:111&&VN4]被新增, hash值為1232193678

[127.0.0.1:1111]的hash值為380278925, 被路由到結點[192.168.0.0:111]
[221.226.0.1:2222]的hash值為1493545632, 被路由到結點[192.168.0.0:111]
[10.211.0.1:3333]的hash值為1393836017, 被路由到結點[192.168.0.2:111]