一致性哈希及java實現

1、一致性hash介紹

一致性哈希算法是分佈式系統中常用的算法。比如，一個分佈式的存儲系統，要將數據存儲到具體的節點上，如果採用普通的hash方法，將數據映射到具體的節點上，如key%N，key是數據的key，N是機器節點數，如果有一個機器加入或退出這個集羣，則所有的數據映射都無效了，如果是持久化存儲則要做數據遷移，如果是分佈式緩存，則其他緩存就失效了。

    因此，引入了一致性哈希算法：

 

把數據用hash函數（如MD5），映射到一個很大的空間裏，如圖所示。數據的存儲時，先得到一個hash值，對應到這個環中的每個位置，如k1對應到了圖中所示的位置，然後沿順時針找到一個機器節點B，將k1存儲到B這個節點中。

如果B節點宕機了，則B上的數據就會落到C節點上，如下圖所示：

 

這樣，只會影響C節點，對其他的節點A，D的數據不會造成影響。然而，這又會造成一個“雪崩”的情況，即C節點由於承擔了B節點的數據，所以C節點的負載會變高，C節點很容易也宕機，這樣依次下去，這樣造成整個集羣都掛了。

       爲此，引入了“虛擬節點”的概念：即把想象在這個環上有很多“虛擬節點”，數據的存儲是沿着環的順時針方向找一個虛擬節點，每個虛擬節點都會關聯到一個真實節點，如下圖所使用：

圖中的A1、A2、B1、B2、C1、C2、D1、D2都是虛擬節點，機器A負載存儲A1、A2的數據，機器B負載存儲B1、B2的數據，機器C負載存儲C1、C2的數據。由於這些虛擬節點數量很多，均勻分佈，因此不會造成“雪崩”現象。

2、實現原理

web架構中，分佈式是個常見的架構設計。尤其是大家比較熟悉的Memcached，或者其他cache產品常常被設計成分佈式集羣。分佈式往往採用hash(key)%n 的方式，但這種算法比較簡單，便於實現和理解。但弊端是不能動態增刪節點。比較合理的方法改用一致性哈希(consistent hashing)分佈。一致性哈希，簡單的說在移除 / 添加一個 cache 時，它能夠儘可能小的改變已存在 key 映射關係，儘可能的滿足單調性的要求。原理不再贅述，google和度娘都能得到答案。重點說一下最常見的實現方式。

 

Java中採用md5散列的方式，計算hash值，這樣基本上能保證key散列出啦的hash不會重複。

private static long md5HashingAlg(String key) {
    MessageDigest md5 = MD5.get();
    md5.reset();
    md5.update(key.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;
}

在對server節點初始化的時候，爲了避免節點過少數據分佈不均勻，都會初始化一些虛擬節點。具體方法上面計算hash值的方式類同，一把採用根據權重虛擬出來一些key，具體不過多介紹。

一致性哈希算法中，把哈希值想象成一個環狀。有關一致性哈希算法，介紹裏面說0~2^32-1的數據，不要誤以爲哈希環要保存2^32個數據。他只是說，哈希環存的key的哈希值範圍是0~2^32-1，並不是key的哈希值要覆蓋0~2^32-1所有數據。

既要保存hash值，又要保存對應的節點地址，貌似最簡單的就是map，在Java中沒有什麼map可以滿足是個環狀。那就找一個排序的，0開頭，2^32-1做尾。查找時查到尾沒有結果，再返回頭找這樣可以理解爲是個環狀了。

在初始化的時候，把節點的hash和節點地址保存在TreeMap裏，client查找時，根據key的hash值去treeMap得到自己應該查詢的節點，往下查找比自己hash值大的，如果有則得到結果返回。如果沒有，則回到treeMap的頭，取第一個返回結果。

如圖中所示：根據key計算出hash，去treeMap查找比key哈希大的那部分，取出第一個值就是結果。如果沒有別key哈希大的部分，則取treeMap的第一個值。

代碼的實現：

private final Long findPointFor(Long hv) {

        SortedMap<Long, String> tmap = this.consistentBuckets.tailMap(hv);

        return (tmap.isEmpty()) ? this.consistentBuckets.firstKey() : tmap.firstKey();
}

3、代碼實現

這幾天看了幾遍一致性哈希的文章，但是都沒有比較完整的實現，因此試着實現了一下，這裏我就不講一致性哈希的原理了，網上很多，以一致性哈希用在負載均衡的實例來說，一致性哈希就是先把主機ip從小大到全部放到一個環內，然後客戶端ip來連接的時候，把客戶端ip連接到大小最接近客戶端ip且大於客戶端ip的主機。當然，這裏的ip一般都是要先hash一下的。我的程序運行結果如下：

    

添加客戶端，一開始有4個主機，分別爲s1,s2,s3,s4,每個主機有100個虛擬主機：
101客戶端（hash：-3872430075274208315）連接到主機->s2-192.168.1.2
102客戶端（hash：-6461488502093916753）連接到主機->s1-192.168.1.1
103客戶端（hash：-3272337528088901176）連接到主機->s3-192.168.1.3
104客戶端（hash：7274050343425899995）連接到主機->s2-192.168.1.2
105客戶端（hash：6218187750346216421）連接到主機->s1-192.168.1.1
106客戶端（hash：-8497989778066313989）連接到主機->s2-192.168.1.2
107客戶端（hash：2219601794372203979）連接到主機->s3-192.168.1.3
108客戶端（hash：1903054837754071260）連接到主機->s3-192.168.1.3
109客戶端（hash：-2425484502654523425）連接到主機->s1-192.168.1.1
刪除主機s2-192.168.1.2的變化：
hash(-8497989778066313989)改變到->s4-192.168.1.4
hash(7274050343425899995)改變到->s2-192.168.1.2
hash(-3872430075274208315)改變到->s4-192.168.1.4
hash(7274050343425899995)改變到->s1-192.168.1.1
增加主機s5-192.168.1.5的變化：
hash(1903054837754071260)改變到->s5-192.168.1.5
hash(1903054837754071260)改變到->s5-192.168.1.5
hash(-3272337528088901176)改變到->s5-192.168.1.5
最後的客戶端到主機的映射爲：
hash(-8497989778066313989)連接到主機->s4-192.168.1.4
hash(-6461488502093916753)連接到主機->s1-192.168.1.1
hash(-3872430075274208315)連接到主機->s4-192.168.1.4
hash(-3272337528088901176)連接到主機->s5-192.168.1.5
hash(-2425484502654523425)連接到主機->s1-192.168.1.1
hash(1903054837754071260)連接到主機->s5-192.168.1.5
hash(2219601794372203979)連接到主機->s3-192.168.1.3
hash(6218187750346216421)連接到主機->s1-192.168.1.1
hash(7274050343425899995)連接到主機->s1-192.168.1.1

看結果可知：一開始添加到9個客戶端，連接到主機s1，s2，s3，s4的客戶端分別有3，3，3，0個，經過刪除主機s2，添加主機s5，最後9個客戶端分別連接到主機s1,s2,s3,s4,s5的個數爲4，0，１，２，２.這裏要說明一下刪除主機s2的情況，hash尾號爲9995的客戶端先連接到s2，再連接到s1，爲什麼會出現這種情況呢？因爲每一個真實主機有ｎ個虛擬主機，刪除ｓ２卻打印“hash(7274050343425899995)改變到->s2-192.168.1.2”是因爲刪除了ｓ２的其中一個虛擬主機，跳轉到另一個虛擬主機，但還是在ｓ２上，當然，這裏是打印中間情況，以便了解，真實的環境是刪除了ｓ２後，所有他的虛擬節點都會馬上被刪除，虛擬節點上的連接也會重新連接到另一個主機的虛擬節點，不會存在這種中間情況。

以下給出所有的實現代碼，大家共同學習：

public class Shard<Node> { // S類封裝了機器節點的信息 ，如name、password、ip、port等

    static private TreeMap<Long, Node> nodes; // 虛擬節點到真實節點的映射
    static private TreeMap<Long,Node> treeKey; //key到真實節點的映射
    static private List<Node> shards = new ArrayList<Node>(); // 真實機器節點
    private final int NODE_NUM = 100; // 每個機器節點關聯的虛擬節點個數
    boolean flag = false;

    public Shard(List<Node> shards) {
        super();
        this.shards = shards;
        init();
    }

    public static void main(String[] args) {
//      System.out.println(hash("w222o1d"));
//      System.out.println(Long.MIN_VALUE);
//      System.out.println(Long.MAX_VALUE);
        Node s1 = new Node("s1", "192.168.1.1");
        Node s2 = new Node("s2", "192.168.1.2");
        Node s3 = new Node("s3", "192.168.1.3");
        Node s4 = new Node("s4", "192.168.1.4");
        Node s5 = new Node("s5","192.168.1.5");
        shards.add(s1);
        shards.add(s2);
        shards.add(s3);
        shards.add(s4);
        Shard<Node> sh = new Shard<Shard.Node>(shards);
        System.out.println("添加客戶端，一開始有4個主機，分別爲s1,s2,s3,s4,每個主機有100個虛擬主機：");
        sh.keyToNode("101客戶端");
        sh.keyToNode("102客戶端");
        sh.keyToNode("103客戶端");
        sh.keyToNode("104客戶端");
        sh.keyToNode("105客戶端");
        sh.keyToNode("106客戶端");
        sh.keyToNode("107客戶端");
        sh.keyToNode("108客戶端");
        sh.keyToNode("109客戶端");

        sh.deleteS(s2);


        sh.addS(s5);

        System.out.println("最後的客戶端到主機的映射爲：");
        printKeyTree();
    }
    public static void printKeyTree(){
        for(Iterator<Long> it = treeKey.keySet().iterator();it.hasNext();){
            Long lo = it.next();
            System.out.println("hash("+lo+")連接到主機->"+treeKey.get(lo));
        }

    }

    private void init() { // 初始化一致性hash環
        nodes = new TreeMap<Long, Node>();
        treeKey = new TreeMap<Long, Node>();
        for (int i = 0; i != shards.size(); ++i) { // 每個真實機器節點都需要關聯虛擬節點
            final Node shardInfo = shards.get(i);

            for (int n = 0; n < NODE_NUM; n++)
                // 一個真實機器節點關聯NODE_NUM個虛擬節點
                nodes.put(hash("SHARD-" + shardInfo.name + "-NODE-" + n), shardInfo);
        }
    }
    //增加一個主機
    private void addS(Node s) {
        System.out.println("增加主機"+s+"的變化：");
        for (int n = 0; n < NODE_NUM; n++)
            addS(hash("SHARD-" + s.name + "-NODE-" + n), s);

    }

    //添加一個虛擬節點進環形結構,lg爲虛擬節點的hash值
    public void addS(Long lg,Node s){
        SortedMap<Long, Node> tail = nodes.tailMap(lg);
        SortedMap<Long,Node>  head = nodes.headMap(lg);
        Long begin = 0L;
        Long end = 0L;
        SortedMap<Long, Node> between;
        if(head.size()==0){
            between = treeKey.tailMap(nodes.lastKey());
            flag = true;
        }else{
            begin = head.lastKey();
            between = treeKey.subMap(begin, lg);
            flag = false;
        }
        nodes.put(lg, s);
        for(Iterator<Long> it=between.keySet().iterator();it.hasNext();){
            Long lo = it.next();
            if(flag){
                treeKey.put(lo, nodes.get(lg));
                System.out.println("hash("+lo+")改變到->"+tail.get(tail.firstKey()));
            }else{
                treeKey.put(lo, nodes.get(lg));
                System.out.println("hash("+lo+")改變到->"+tail.get(tail.firstKey()));
            }
        }
    }

    //刪除真實節點是s
    public void deleteS(Node s){
        if(s==null){
            return;
        }
        System.out.println("刪除主機"+s+"的變化：");
        for(int i=0;i<NODE_NUM;i++){
            //定位s節點的第i的虛擬節點的位置
            SortedMap<Long, Node> tail = nodes.tailMap(hash("SHARD-" + s.name + "-NODE-" + i));
            SortedMap<Long,Node>  head = nodes.headMap(hash("SHARD-" + s.name + "-NODE-" + i));
            Long begin = 0L;
            Long end = 0L;

            SortedMap<Long, Node> between;
            if(head.size()==0){
                between = treeKey.tailMap(nodes.lastKey());
                end = tail.firstKey();
                tail.remove(tail.firstKey());
                nodes.remove(tail.firstKey());//從nodes中刪除s節點的第i個虛擬節點
                flag = true;
            }else{
                begin = head.lastKey();
                end = tail.firstKey();
                tail.remove(tail.firstKey());
                between = treeKey.subMap(begin, end);//在s節點的第i個虛擬節點的所有key的集合
                flag = false;
            }
            for(Iterator<Long> it = between.keySet().iterator();it.hasNext();){
                Long lo  = it.next();
                if(flag){
                    treeKey.put(lo, tail.get(tail.firstKey()));
                    System.out.println("hash("+lo+")改變到->"+tail.get(tail.firstKey()));
                }else{
                    treeKey.put(lo, tail.get(tail.firstKey()));
                    System.out.println("hash("+lo+")改變到->"+tail.get(tail.firstKey()));
                }
            }
        }

    }

    //映射key到真實節點
    public void keyToNode(String key){
        SortedMap<Long, Node> tail = nodes.tailMap(hash(key)); // 沿環的順時針找到一個虛擬節點
        if (tail.size() == 0) {
            return;
        }
        treeKey.put(hash(key), tail.get(tail.firstKey()));
        System.out.println(key+"（hash："+hash(key)+"）連接到主機->"+tail.get(tail.firstKey()));
    }

    /**
     *  MurMurHash算法，是非加密HASH算法，性能很高，
     *  比傳統的CRC32,MD5，SHA-1（這兩個算法都是加密HASH算法，複雜度本身就很高，帶來的性能上的損害也不可避免）
     *  等HASH算法要快很多，而且據說這個算法的碰撞率很低.
     *  http://murmurhash.googlepages.com/
     */
    private static Long hash(String key) {

        ByteBuffer buf = ByteBuffer.wrap(key.getBytes());
        int seed = 0x1234ABCD;

        ByteOrder byteOrder = buf.order();
        buf.order(ByteOrder.LITTLE_ENDIAN);

        long m = 0xc6a4a7935bd1e995L;
        int r = 47;

        long h = seed ^ (buf.remaining() * m);

        long k;
        while (buf.remaining() >= 8) {
            k = buf.getLong();

            k *= m;
            k ^= k >>> r;
            k *= m;

            h ^= k;
            h *= m;
        }

        if (buf.remaining() > 0) {
            ByteBuffer finish = ByteBuffer.allocate(8).order(
                    ByteOrder.LITTLE_ENDIAN);
            // for big-endian version, do this first:
            // finish.position(8-buf.remaining());
            finish.put(buf).rewind();
            h ^= finish.getLong();
            h *= m;
        }

        h ^= h >>> r;
        h *= m;
        h ^= h >>> r;

        buf.order(byteOrder);
        return h;
    }

    static class Node{
        String name;
        String ip;
        public Node(String name,String ip) {
            this.name = name;
            this.ip = ip;
        }
        @Override
        public String toString() {
            return this.name+"-"+this.ip;
        }
    }

}

4、關於treeMap的一些方法的介紹

4.1 tailMap（）

tailMap(K fromKey) 方法用於返回此映射，其鍵大於或等於fromKey的部分視圖。返回的映射受此映射支持，因此改變返回映射反映在此映射中，反之亦然。

以下是java.util.TreeMap.tailMap()方法的聲明。

public SortedMap<K,V> tailMap(K fromKey)

參數
fromKey--返回映射中鍵的低端點(包括)

返回值

該方法調用返回此映射，其鍵大於或等於fromKey的部分視圖。

例子：

下面的示例演示java.util.TreeMap.tailMap()方法的使用

package com.yiibai;

import java.util.*;

public class TreeMapDemo {
   public static void main(String[] args) {
      // creating maps 
      TreeMap<Integer, String> treemap = new TreeMap<Integer, String>();
      SortedMap<Integer, String> treemapincl = new TreeMap<Integer, String>();
            
      // populating tree map
      treemap.put(2, "two");
      treemap.put(1, "one");
      treemap.put(3, "three");
      treemap.put(6, "six");
      treemap.put(5, "five");      
      
      System.out.println("Getting tail map");
      treemapincl=treemap.tailMap(3);
      System.out.println("Tail map values: "+treemapincl);      
   }    
}

現在編譯和運行上面的代碼示例，將產生以下結果。

Getting tail map
Tail map values: {3=three, 5=five, 6=six}

4.2 headMap（）

headMap(K toKey) 方法用於返回此映射的鍵嚴格小於toKey的部分視圖。

4.3 java.util.TreeMap類

java.util.TreeMap 類是Red-Black樹實現基於Map接口。以下是關於TreeMap中重要的幾點：

TreeMap類保證該映射將是升序鍵順序。

該映射是按照自然排序方法的關鍵類，或者根據創建映射時提供的比較器，這將取決於其構造函數中使用排序。