一致性hash算法及java實現

典型的應用場景是： 有N台服務器提供緩存服務，需要對服務器進行負載均衡，將請求平均分發到每台服務器上，每台機器負責1/N的服務。

常用的算法是對hash結果取余數 (hash() mod N )：對機器編號從0到N-1，按照自定義的 hash()算法，對每個請求的hash()值按N取模，得到余數i，然后將請求分發到編號為i的機器。但這樣的算法方法存在致命問題，如果某一台機器宕機，那么應該落在該機器的請求就無法得到正確的處理，這時需要將當掉的服務器從算法從去除，此時候會有(N-1)/N的服務器的緩存數據需要重新進行計算;如果新增一台機器，會有N /(N+1)的服務器的緩存數據需要進行重新計算。

一致性哈希算法(Consistent Hashing Algorithm)是一種分布式算法，常用於負載均衡。Memcached client也選擇這種算法，解決將key-value均勻分配到眾多Memcached server上的問題。它可以取代傳統的取模操作，解決了取模操作無法應對增刪Memcached Server的問題(增刪server會導致同一個key,在get操作時分配不到數據真正存儲的server，命中率會急劇下降)。

簡單來說，一致性哈希將整個哈希值空間組織成一個虛擬的圓環，如假設某哈希函數H的值空間為0 - (2^32)-1（即哈希值是一個32位無符號整形）

以下是自己總結的：

不帶虛擬節點的一致性hash算法流程

1、定義一個服務器列表信息；

2、將服務器列表計算出hash值，並添加到map中（或者redis中）；

3、計算出key值得hash值；

4、在map中取出大於此hash值得列表；

5、如果有則順時針取出離node最近節點的服務器；

6、如果沒有則取出map中第一個節點即可；

7、完畢；

代碼如下：

//待添加入Hash環的服務器列表
private static String[] servers = { "192.168.0.1:8080", "192.168.0.2:8080",
        "192.168.0.3:8080", "192.168.0.4:8080", "192.168.0.5:8080" };

//key表示服務器的hash值，value表示服務器
private static SortedMap<Integer, String> sortedMap = new TreeMap<Integer, String>();

//程序初始化，將所有的服務器放入sortedMap中
static {
    for (int i=0; i<servers.length; i++) {
        int hash = getHash(servers[i]);
        System.out.println("[" + servers[i] + "]加入集合中, 其Hash值為" + hash);
        sortedMap.put(hash, servers[i]);
    }
    System.out.println();
}

//得到應當路由到的結點
private static String getServer(String key) {
    //得到該key的hash值
    int hash = getHash(key);
    //得到大於該Hash值的所有Map
    SortedMap<Integer, String> subMap = sortedMap.tailMap(hash);
    if(subMap.isEmpty()){
        //如果沒有比該key的hash值大的，則從第一個node開始
        Integer i = sortedMap.firstKey();
        //返回對應的服務器
        return sortedMap.get(i);
    }else{
        //第一個Key就是順時針過去離node最近的那個結點
        Integer i = subMap.firstKey();
        //返回對應的服務器
        return subMap.get(i);
    }
}

//使用FNV1_32_HASH算法計算服務器的Hash值,這里不使用重寫hashCode的方法，最終效果沒區別
private static int getHash(String str) {
    final int p = 16777619;
    int hash = (int) 2166136261L;
    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;

    // 如果算出來的值為負數則取其絕對值
    if (hash < 0)
        hash = Math.abs(hash);
    return hash;
}

public static void main(String[] args) {
    String[] keys = {"香蕉", "菠蘿", "蜂蜜"};
    for(int i=0; i<keys.length; i++)
        System.out.println("[" + keys[i] + "]的hash值為" + getHash(keys[i])
                + ", 被路由到結點[" + getServer(keys[i]) + "]");
}

　　帶虛擬接待的一致性hash算法流程

1、先把原始的服務器添加到真實結點列表中；

2、再添加虛擬節點，遍歷LinkedList使用foreach循環效率會比較高；

3、得到該key的hash值；

4、得到大於該Hash值的所有Map；

5、如果沒有比該key的hash值大的，則從第一個node開始；

6、如果有則第一個Key就是順時針過去離node最近的那個結點

7、返回對應的服務器；

8、virtualNode虛擬節點名稱要截取一下；

9、結束

 

代碼如下：

//待添加入Hash環的服務器列表
private static String[] servers = {"192.168.0.1:8080", "192.168.0.2:8080", "192.168.0.3:8080",
        "192.168.0.4:8080", "192.168.0.5:8080"};

//真實結點列表,考慮到服務器上線、下線的場景，即添加、刪除的場景會比較頻繁，這里使用LinkedList會更好
private static List<String> realNodes = new LinkedList<String>();

//虛擬節點，key表示虛擬節點的hash值，value表示虛擬節點的名稱
private static SortedMap<Integer, String> virtualNodes = new TreeMap<Integer, String>();

//虛擬節點的數目，這里寫死，為了演示需要，一個真實結點對應5個虛擬節點
private static final int VIRTUAL_NODES = 5;

static{
    //先把原始的服務器添加到真實結點列表中
    for(int i=0; i<servers.length; i++)
        realNodes.add(servers[i]);

    //再添加虛擬節點，遍歷LinkedList使用foreach循環效率會比較高
    for (String str : realNodes){
        for(int i=0; i<VIRTUAL_NODES; i++){
            String virtualNodeName = str + "&&VN" + String.valueOf(i);
            int hash = getHash(virtualNodeName);
            System.out.println("虛擬節點[" + virtualNodeName + "]被添加, hash值為" + hash);
            virtualNodes.put(hash, virtualNodeName);
        }
    }
    System.out.println();
}

//使用FNV1_32_HASH算法計算服務器的Hash值,這里不使用重寫hashCode的方法，最終效果沒區別
private static int getHash(String str){
    final int p = 16777619;
    int hash = (int)2166136261L;
    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;

    // 如果算出來的值為負數則取其絕對值
    if (hash < 0)
        hash = Math.abs(hash);
    return hash;
}

//得到應當路由到的結點
private static String getServer(String key){
    //得到該key的hash值
    int hash = getHash(key);
    // 得到大於該Hash值的所有Map
    SortedMap<Integer, String> subMap = virtualNodes.tailMap(hash);
    String virtualNode;
    if(subMap.isEmpty()){
        //如果沒有比該key的hash值大的，則從第一個node開始
        Integer i = virtualNodes.firstKey();
        //返回對應的服務器
        virtualNode = virtualNodes.get(i);
    }else{
        //第一個Key就是順時針過去離node最近的那個結點
        Integer i = subMap.firstKey();
        //返回對應的服務器
        virtualNode = subMap.get(i);
    }
    //virtualNode虛擬節點名稱要截取一下
    if(!StringUtils.isEmpty(virtualNode)){
        return virtualNode.substring(0, virtualNode.indexOf("&&"));
    }
    return null;
}

public static void main(String[] args){
    String[] keys = {"香蕉", "菠蘿", "蜂蜜"};
    for(int i=0; i<keys.length; i++)
        System.out.println("[" + keys[i] + "]的hash值為" +
                getHash(keys[i]) + ", 被路由到結點[" + getServer(keys[i]) + "]");
}

　　如有疑問，請留言，我會一一解答。