2. 程式人生 > >一致性Hash演算法的實現

一致性Hash演算法的實現

阿新 • • 發佈：2019-01-05

一致性hash作為一個負載均衡演算法，可以用在分散式快取、資料庫的分庫分表等場景中，還可以應用在負載均衡器中作為作為負載均衡演算法。在有多臺伺服器時，對於某個請求資源通過hash演算法，對映到某一個臺伺服器，當增加或減少一臺伺服器時，可能會改變這些資源對應的hash值，這樣可能導致一部分快取或資料失效了。一致性hash就是儘可能在將同一個資源請求路由到同一臺伺服器中。

本篇文章將模擬實現一個分散式快取系統來探討在使用了一致性hash以及普通hash在增加、刪除節點之後，對資料分佈、快取命中率的影響

節點&叢集設計

在一個分散式快取系統中，每臺機器可以認為是一個節點，節點作為資料儲存的地方，由一些節點來組成一個叢集。我們先來設計我們的節點和叢集。

節點

@Data
public class Node {

    private String domain;

    private String ip;

    private Map<String, Object> data;

    public <T> void put(String key, T value) {
        data.put(key, value);
    }

    public void remove(String key){
        data.remove(key);
    }

    public
 
 <T> T get(String key) {
        return (T) data.get(key);
    }
}

一個節點包括domain(域名)，ip(IP地址)，data(節點儲存資料)，節點可以存放、刪除、獲取資料。

叢集

public abstract class Cluster {

    protected List<Node> nodes;

    public Cluster() {
        this.nodes = new ArrayList<>();
    }

    public abstract
 
 void addNode(Node node);

    public abstract void removeNode(Node node);

    public abstract Node get(String key);
}

在一個叢集中包含多個節點，可以在一個叢集中，增加、刪除節點。還可以通過key獲取資料儲存的節點。

取模

在使用取模的場景中，當一個請求資源，請求某個叢集時，通過對請求資源進行hash得到的值，然後對儲存叢集的節點數取模來得到，該請求資源，應該儲存到哪一個儲存節點。

具體實現如下：

public class NormalHashCluster extends Cluster {

    public NormalHashCluster() {
        super();
    }

    @Override
    public void addNode(Node node) {
        this.nodes.add(node);
    }

    @Override
    public void removeNode(Node node) {
        this.nodes.removeIf(o -> o.getIp().equals(node.getIp()) ||
                o.getDomain().equals(node.getDomain()));
    }

    @Override
    public Node get(String key) {
        long hash = hash(key);
        long index =  hash % nodes.size();
        return nodes.get((int)index);
    }
}

下面我們對該演算法，在資料分佈、增加一個節點、刪除一個節點對快取的命中率影響做一個測試

        Cluster cluster = new NormalHashCluster();
        cluster.addNode(new Node("c1.yywang.info", "192.168.0.1"));
        cluster.addNode(new Node("c2.yywang.info", "192.168.0.2"));
        cluster.addNode(new Node("c3.yywang.info", "192.168.0.3"));
        cluster.addNode(new Node("c4.yywang.info", "192.168.0.4"));

        IntStream.range(0, DATA_COUNT)
                .forEach(index -> {
                    Node node = cluster.get(PRE_KEY + index);
                    node.put(PRE_KEY + index, "Test Data");
                });

        System.out.println("資料分佈情況：");
        cluster.nodes.forEach(node -> {
            System.out.println("IP:" + node.getIp() + ",資料量:" + node.getData().size());
        });

        //快取命中率
        long hitCount = IntStream.range(0, DATA_COUNT)
                .filter(index -> cluster.get(PRE_KEY + index).get(PRE_KEY + index) != null)
                .count();
        System.out.println("快取命中率：" + hitCount * 1f / DATA_COUNT);

在初始狀態下，資料的分佈和快取命中率如下：

資料分佈情況：
IP:192.168.0.1,資料量:12499
IP:192.168.0.2,資料量:12501
IP:192.168.0.3,資料量:12499
IP:192.168.0.4,資料量:12501
快取命中率：1.0

從以上資料可以看出，資料分佈較均勻，在不增不減節點的情況下，快取全部命中

我們新增一個節點

//增加一個節點
cluster.addNode(new Node("c5.yywang.info", "192.168.0.5"));

這時快取命中率

增加一個節點的快取命中率：0.19808

我們來刪除一個節點

cluster.removeNode(new Node("c4.yywang.info", "192.168.0.4"));

這時快取命中率

刪除快取命中率：0.25196

從以上可以看出，通過取模演算法，在增加節點、刪除節點時，將對快取命中率產生極大的影響，所以在該場景中如果使用取模運算將會產生很多的資料遷移量。

一致性hash

為了解決以上取模運算的缺點，我們引入一致性hash演算法，一致性hash演算法的原理如下：

首先我們把2的32次方想象成一個環，比如：

hash1

假如我們有四臺伺服器分佈這個環上，其中Node1,Node2,Node3,Node4就表示這四臺伺服器在環上的位置，一致性hash演算法就是，在快取的Key的值計算後得到的hash值，對映到這個環上的點，然後這些點按照順時針方向找，找到離自己最近的一個物理節點就是自己要儲存的節點。

當我們增加了一個節點如下：

hash2

我們增加了Node5放在Node3和Node4之間，這時我們可以看到增加了一個節點只會影響Node3至Node5之間的資料，其他節點的資料不會受到影響。同時我們還可以看到，Node4和Node5的壓力要小於其他節點，大約是其他節點的一半。這樣就帶了壓力分佈均勻的情況，假定Node4和Node5的機器配置和其它的節點機器配置相同，那麼Node4和Node5的機器資源就浪費了一半，那麼怎麼解決這個問題呢？

我們引入虛擬節點，簡單來說，虛擬節點就是不存在的點，這些虛擬節點儘量的分佈在環上，需要做的就是把這些虛擬節點需要對映到物理節點。

hash3

在引入虛擬節點後，我們把虛擬節點上均勻的分佈到環上，然後把虛擬節點對映到物理節點，當增加了新的機器後，我們只需要把虛擬節點對映到新的機器即可，這樣就解決了機器壓力分佈不均勻的情況

上面我們說了一致性hash的基本演算法，下面我們來看下具體實現

public class ConsistencyHashCluster extends Cluster {

    private SortedMap<Long, Node> virNodes = new TreeMap<Long, Node>();

    private static final int VIR_NODE_COUNT = 512;

    private static final String SPLIT = "#";

    public ConsistencyHashCluster() {
        super();
    }

    @Override
    public void addNode(Node node) {
        this.nodes.add(node);
        IntStream.range(0, VIR_NODE_COUNT)
                .forEach(index -> {
                    long hash = hash(node.getIp() + SPLIT + index);
                    virNodes.put(hash, node);
                });
    }

    @Override
    public void removeNode(Node node) {
        nodes.removeIf(o -> node.getIp().equals(o.getIp()));
        IntStream.range(0, VIR_NODE_COUNT)
                .forEach(index -> {
                    long hash = hash(node.getIp() + SPLIT + index);
                    virNodes.remove(hash);
                });
    }

    @Override
    public Node get(String key) {
        long hash = hash(key);
        SortedMap<Long, Node> subMap = hash >= virNodes.lastKey() ? virNodes.tailMap(0L) : virNodes.tailMap(hash);
        if (subMap.isEmpty()) {
            return null;
        }
        return subMap.get(subMap.firstKey());
    }
}

下面我們同樣對一致性hash演算法，在資料分佈、增加一個節點、刪除一個節點對快取的命中率影響做一個測試

測試程式碼很簡單，我們只需要把以上的程式碼替換成ConsistencyHashCluster實現即可

//        Cluster cluster = new NormalHashCluster();
        Cluster cluster=new ConsistencyHashCluster();

在初始狀態下，資料的分佈和快取命中率如下：

資料分佈情況：
IP:192.168.0.1,資料量:15345
IP:192.168.0.2,資料量:14084
IP:192.168.0.3,資料量:10211
IP:192.168.0.4,資料量:10360
快取命中率：1.0

從以上資料可以看出，資料分佈相對均勻，沒有取模演算法的均勻，在不增不減節點的情況下，快取全部命中

我們增加一個節點

cluster.addNode(new Node("c" + 5 + ".yywang.info", "192.168.0." + 5));

這時快取命中率

增加一個節點的快取命中率：0.82154

可以看出快取命中率明顯高於取模運算的命中率

我們刪除一個節點

cluster.removeNode(new Node("c4.yywang.info", "192.168.0.4"));

這時快取命中率

刪除一個節點的快取命中率：0.7928

從以上可以看出，我們可以看出使用一致性hash演算法，可以極大的提高快取的命中率，減少在增加節點、刪除節點時，資料遷移的成本。

歡迎關注我的公眾號MyArtNote

MyArtNote

相關推薦

twemproxy0.4原理分析-一致性hash演算法實現ketama分析

概述 本文是一致性hash演算法的一種開原始碼的實現：ketama的原始碼分析。 本文是我多年前的一篇文章整理而來，以前的那篇文章的連結可以在這裡檢視。 簡介 若我們在後臺使用NoSQL叢集，必然會涉及到key的分配問題，叢集中某臺機器宕機時如何key又該如何分配的問題。

memcache客戶端實現叢集之一致性hash演算法

一致性雜湊的演算法把取餘演算法的等於號來選擇mem伺服器變成了大於號來選擇mem伺服器，這應該是才是關鍵，可以使一個鍵的mem伺服器落點變成是動態選擇（一個伺服器down掉然後選擇crc32(key)後大於這個伺服器的落點....） 新增虛擬節點，虛擬節點其實還是原來那幾臺伺服器，每個虛擬節

一致性hash演算法程式碼實現

什麼是一致性hash 一致性雜湊演算法(Consistent Hashing Algorithm)是一種分散式演算法，常用於負載均衡。Memcached client也選擇這種演算法，解決將key-value均勻分配到眾多Memcached server上的問題。它可以取代傳統的取模操作

一致性Hash演算法，Java程式碼實現

一致性Hash演算法 關於一致性Hash演算法，在我之前的博文中已經有多次提到了，MemCache超詳細解讀一文中"一致性Hash演算法"部分，對於為什麼要使用一致性Hash演算法、一致性Hash演算法的演算法原理做了詳細的解讀。 演算法的具體原理這裡再次貼上： 先構造

一致性Hash演算法的實現

一致性hash作為一個負載均衡演算法，可以用在分散式快取、資料庫的分庫分表等場景中，還可以應用在負載均衡器中作為作為負載均衡演算法。在有多臺伺服器時，對於某個請求資源通過hash演算法，對映到某一個臺伺服器，當增加或減少一臺伺服器時，可能會改變這些資源對應的ha

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

1 /** 2 * 帶虛擬節點的一致性Hash演算法 3 * @author 五月的倉頡 http://www.cnblogs.com/xrq730/ 4 */ 5 public class ConsistentHashingWithVirtualNode 6 { 7

memcache分散式 [一致性hash演算法] 的php實現

 最近在看一些分散式方面的文章，所以就用php實現一致性hash來練練手，以前一般用的是最原始的hash取模做 分散式，當生產過程中新增或刪除一臺memcache都會造成資料的全部失效，一致性hash就是為了解決這個問題，把失效資料降到最低，相關資料可以 google一下！ php實現效率有一定的缺失，如

一致性hash演算法 java實現

public class NoName { private static final Map<String,String> ipMap = new HashMap<String, String>(); private static f

一致性hash演算法 java程式碼實現與測試

轉載：http://blog.csdn.net/pcceo1/article/details/51493934 寫了一個一致性hash的Java實現程式碼，演算法是用別人的，據說很好，然後自己做了一個測試，用執行緒池起了1000個執行緒，每個執行緒hash10000次，模

圖解一致性hash演算法和實現

更多內容，歡迎關注微信公眾號：全菜工程師小輝。公眾號回覆關鍵詞，領取免費學習資料。 一致性hash演算法是什麼？ 一致性hash演

關於什麼是一致性hash演算法

當需要分散式快取的時候，通過key的hash值分散資料儲存hash(n)%快取伺服器臺數，同時也可以快速查詢資料而不用遍歷所有的伺服器。如下圖： 但是這樣，當業務拓展想要增加一臺伺服器的話，要麼快取伺服器資料全部需要重新計算儲存 -----hash(n)%5 。 要麼需要遍歷所有快取伺服器。不夠靈活。

一致性Hash演算法的深入理解

總結： 1、使用一致性Hash演算法，儘管增強了系統的伸縮性，但是也有可能導致負載分佈不均勻，解決辦法就是使用虛擬節點代替真實節點，  2、Hash演算法的選擇上，首先我們考慮簡單的String.HashCode()方法，這個演算法的缺點是，相似的字串如N1(10.0.

分散式演算法(一致性Hash演算法)

一、分散式演算法     在做伺服器負載均衡時候可供選擇的負載均衡的演算法有很多，包括： 輪循演算法(Round Robin)、雜湊演算法(HASH)、最少連線演算法(Least Connection)、響應速度演算法(Response Time)、加權法

Java架構/一致性Hash演算法在資料庫分表中的實踐

最近有一個專案，其中某個功能單表資料在可預估的未來達到了億級，初步估算在90億左右。與同事詳細討論後，決定採用一致性Hash演算法來完成資料庫的自動擴容和資料遷移。整個程式細節由我同事完成，我只是將其理解併成文，供有相同問題的同行參考。 參看此文的兄弟，預設各位已經熟悉一致性hash

一致性hash java實現

前言 之前講了 一致性hash演算法的原理，現在擼程式碼。 環的資料結構，可能首先想到的是常用的List。一致性hash需要找比當前元素大的節點，那麼list要麼排好序然後比較找到對應的節點，要麼是不排序直接遍歷算差值。顯然在這種查詢比較頻繁的場景樹結構更適合，所以我們用

一致性Hash演算法在資料庫分表中的實踐

最近有一個專案，其中某個功能單表資料在可預估的未來達到了億級，初步估算在90億左右。與同事詳細討論後，決定採用一致性Hash演算法來完成資料庫的自動擴容和資料遷移。整個程式細節由我同事完成，我只是將其理解併成文，供有相同問題的同行參考。 參看此文的兄弟，預設各位已經熟悉一致性hash演算法了。此文僅僅闡述程式

分散式一致性hash演算法

寫在前面   在學習Redis的叢集內容時，看到這麼一句話：Redis並沒有使用一致性hash演算法，而是引入雜湊槽的概念。而分散式快取Memcached則是使用分散式一致性hash演算法來實現分散式儲存。所以就專門學習了一下 什麼是分散式？什麼是一致性？什麼是雜湊？   1

什麼是一致性Hash演算法？

最近有小夥伴跑過來問什麼是Hash一致性演算法，說面試的時候被問到了，因為不瞭解，所以就沒有回答上，問我有沒有相應的學習資料推薦，當時上班，沒時間回覆，晚上回去了就忘了這件事，今天突然看到這個，加班為大家整理一下什麼是Hash一致性演算法，希望對大家有幫助！文末送書，長按抽獎助手小程式即可參與，祝君好運！

一致性 Hash 演算法（分散式或均衡演算法）

簡介： 一致性雜湊演算法在1997年由麻省理工學院提出的一種分散式雜湊（DHT）實現演算法，設計目標是為了解決因特網中的熱點(Hot spot)問題，初衷和CARP十分類似。一致性雜湊修正了CARP使用的簡單雜湊演算法帶來的問題，使得分散式雜湊（DHT）可以在P

一致性 hash 演算法（ consistent hashing ）

1 基本場景 比如你有 N 個 cache 伺服器（後面簡稱 cache ），那麼如何將一個物件 object 對映到 N 個 cache 上呢，你很可能會採用類似下面的通用方法計算 object 的 hash 值，然後均勻的對映到到 N 個 cache hash(obj