一致性hash算法

最新推荐文章于 2025-06-22 21:07:06 发布

原创最新推荐文章于 2025-06-22 21:07:06 发布 · 245 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#一致性hash

计算机基础专栏收录该内容

8 篇文章

订阅专栏

一、使用场景

比如你有 N 个 cache 服务器（后面简称 cache ），那么如何将一个对象 object 映射到 N 个 cache 上呢，你很可能会采用类似下面的通用方法计算 object 的 hash 值，然后均匀的映射到到 N 个 cache ；

hash(object)%N

一切都运行正常，再考虑如下的两种情况；

一个 cache 服务器 m down 掉了（在实际应用中必须要考虑这种情况），这样所有映射到 cache m 的对象都会失效，怎么办，需要把 cache m 从 cache 中移除，这时候 cache 是 N-1 台，映射公式变成了 hash(object)%(N-1) ；
由于访问加重，需要添加 cache ，这时候 cache 是 N+1 台，映射公式变成了 hash(object)%(N+1) ；

1 和 2 意味着什么？这意味着突然之间几乎所有的 cache 都失效了。对于服务器而言，这是一场灾难，洪水般的访问都会直接冲向后台服务器；再来考虑第三个问题，由于硬件能力越来越强，你可能想让后面添加的节点多做点活，显然上面的 hash 算法也做不到。

有什么方法可以改变这个状况呢，一致性hash算法登场了。

二、原理

　　其实，一致性哈希算法也是使用取模的方法，只是，刚才描述的取模法是对服务器的数量进行取模，而一致性哈希算法是对 2^32 取模，什么意思呢？

　　首先，我们把二的三十二次方想象成一个圆，就像钟表一样，钟表的圆可以理解成由60个点组成的圆，而此处我们把这个圆想象成由2^32个点组成的圆，示意图如下：

　　　　　　　　　　　　　　　　　　　　一致性哈希算法基本概念图示1.png-2.6kB

　　圆环的正上方的点代表0，0点右侧的第一个点代表1，以此类推，2、3、4、5、6……直到2^32-1,也就是说0点左侧的第一个点代表2^32-1
我们把这个由2的32次方个点组成的圆环称为 hash环。

　　那么，一致性哈希算法与上图中的圆环有什么关系呢？我们继续聊，仍然以之前描述的场景为例，假设我们有3台缓存服务器，服务器A、服务器B、服务器C，那么，在生产环境中，这三台服务器肯定有自己的IP地址，我们使用它们各自的IP地址进行哈希计算，使用哈希后的结果对2^32取模，可以使用如下公式示意。

hash（服务器A的IP地址） % 2^32

　　通过上述公式算出的结果一定是一个0到2^32-1之间的一个整数，我们就用算出的这个整数，代表服务器A，既然这个整数肯定处于0到2^32-1之间，那么，上图中的hash环上必定有一个点与这个整数对应，而我们刚才已经说明，使用这个整数代表服务器A，那么，服务器A就可以映射到这个环上，用下图示意：

　　　　　　　　　　　　　　　　　　　　一致性哈希算法基本概念图示2.png-3.1kB

　　同理，服务器B与服务器C也可以通过相同的方法映射到上图中的hash环中：

　　hash（服务器B的IP地址） % 2^32
　　hash（服务器C的IP地址） % 2^32

　　通过上述方法，可以将服务器B与服务器C映射到上图中的hash环上，示意图如下：

　　　　　　　　　　　　　　　一致性哈希算法基本概念图示3.png-9.1kB

　　假设3台服务器映射到hash环上以后如上图所示（当然，这是理想的情况，我们慢慢聊）。

　　好了，到目前为止，我们已经把缓存服务器与hash环联系在了一起，我们通过上述方法，把缓存服务器映射到了hash环上，那么使用同样的方法，我们也可以将需要缓存的对象映射到hash环上。

　　假设，我们需要使用缓存服务器缓存图片，而且我们仍然使用图片的名称作为找到图片的key，那么我们使用如下公式可以将图片映射到上图中的hash环上。

hash（图片名称） % 2^32

　　映射后的示意图如下，下图中的橘黄色圆形表示图片：

　　　　　　　　　　　　　　　一致性哈希算法基本概念图示4.png-19.7kB

　　好了，现在服务器与图片都被映射到了hash环上，那么上图中的这个图片到底应该被缓存到哪一台服务器上呢？上图中的图片将会被缓存到服务器A上，为什么呢？因为从图片的位置开始，沿顺时针方向遇到的第一个服务器 就是A服务器，所以，上图中的图片将会被缓存到服务器A上，如下图所示。

　　　　　　　　　　　　　　　一致性哈希算法基本概念图示5.png-21.3kB

　　没错，一致性哈希算法就是通过这种方法，判断一个对象应该被缓存到哪台服务器上的，将缓存服务器与被缓存对象都映射到hash环上以后，从被缓存对象的位置出发，沿顺时针方向遇到的第一个服务器，就是当前对象将要缓存于的服务器，由于被缓存对象与服务器hash后的值是固定的，所以，在服务器不变的情况下，一张图片必定会被缓存到固定的服务器上，那么，当下次想要访问这张图片时，只要再次使用相同的算法进行计算，即可算出这个图片被缓存在哪个服务器上，直接去对应的服务器查找对应的图片即可。

　　刚才的示例只使用了一张图片进行演示，假设有四张图片需要缓存，示意图如下：

　　　　　　　　　　　　　　　一致性哈希算法基本概念图示6.png-27.8kB

　　1号、2号图片将会被缓存到服务器A上，3号图片将会被缓存到服务器B上，4号图片将会被缓存到服务器C上。

三. 一致性哈希算法的优点

　　经过上述描述，我想兄弟你应该已经明白了一致性哈希算法的原理了，但是话说回来，一致性哈希算法能够解决之前出现的问题吗，我们说过，如果简单的对服务器数量进行取模，那么当服务器数量发生变化时，会产生缓存的雪崩，从而很有可能导致系统崩溃，那么使用一致性哈希算法，能够避免这个问题吗？我们来模拟一遍，即可得到答案。

　　假设，服务器B出现了故障，我们现在需要将服务器B移除，那么，我们将上图中的服务器B从hash环上移除即可，移除服务器B以后示意图如下。

　　　　　　　　　　　　　　　一致性哈希算法基本概念图示7.png-26.7kB

　　在服务器B未移除时，图片3应该被缓存到服务器B中，可是当服务器B移除以后，按照之前描述的一致性哈希算法的规则，图片3应该被缓存到服务器C中，因为从图片3的位置出发，沿顺时针方向遇到的第一个缓存服务器节点就是服务器C，也就是说，如果服务器B出现故障被移除时，图片3的缓存位置会发生改变。

　　　　　　　　　　　　　　　一致性哈希算法基本概念图示8.png-28.9kB

　　但是，图片4仍然会被缓存到服务器C中，图片1与图片2仍然会被缓存到服务器A中，这与服务器B移除之前并没有任何区别，这就是一致性哈希算法的优点，如果使用之前的hash算法，服务器数量发生改变时，所有服务器的所有缓存在同一时间失效了，而使用一致性哈希算法时，服务器的数量如果发生改变，并不是所有缓存都会失效，而是只有部分缓存会失效，前端的缓存仍然能分担整个系统的压力，而不至于所有压力都在同一时间集中到后端服务器上。

　　这就是一致性哈希算法所体现出的优点。

四. 一致性hash的问题：hash环的偏斜

　　在介绍一致性哈希的概念时，我们理想化的将3台服务器均匀的映射到了hash环上，如下图所示：

　　　　　　　　　　　　　　　一致性哈希算法基本概念图示9.png-9.1kB

　　但是，理想很丰满，现实很骨感，我们想象的与实际情况往往不一样。

　　在实际的映射中，服务器可能会被映射成如下模样。

　　　　　　　　　　　　　　　一致性哈希算法基本概念图示10.png-9.1kB

　　聪明如你一定想到了，如果服务器被映射成上图中的模样，那么被缓存的对象很有可能大部分集中缓存在某一台服务器上，如下图所示。

　　　　　　　　　　　　　　　一致性哈希算法基本概念图示11.png-30.8kB

　　上图中，1号、2号、3号、4号、6号图片均被缓存在了服务器A上，只有5号图片被缓存在了服务器B上，服务器C上甚至没有缓存任何图片，如果出现上图中的情况，A、B、C三台服务器并没有被合理的平均的充分利用，缓存分布的极度不均匀，而且，如果此时服务器A出现故障，那么失效缓存的数量也将达到最大值，在极端情况下，仍然有可能引起系统的崩溃，上图中的情况则被称之为hash环的偏斜，那么，我们应该怎样防止hash环的偏斜呢？一致性hash算法中使用 “虚拟节点” 解决了这个问题，我们继续聊。

五.虚拟节点

　　话接上文，由于我们只有3台服务器，当我们把服务器映射到hash环上的时候，很有可能出现hash环偏斜的情况，当hash环偏斜以后，缓存往往会极度不均衡的分布在各服务器上，聪明如你一定已经想到了，如果想要均衡的将缓存分布到3台服务器上，最好能让这3台服务器尽量多的、均匀的出现在hash环上，但是，真实的服务器资源只有3台，我们怎样凭空的让它们多起来呢，没错，就是凭空的让服务器节点多起来，既然没有多余的真正的物理服务器节点，我们就只能将现有的物理节点通过虚拟的方法复制出来，这些由实际节点虚拟复制而来的节点被称为”虚拟节点”。加入虚拟节点以后的hash环如下。

　　　　　　　　　　　　　　　一致性哈希算法基本概念图示12.png-23.1kB

　　“虚拟节点”是”实际节点”（实际的物理服务器）在hash环上的复制品,一个实际节点可以对应多个虚拟节点。

　　从上图可以看出，A、B、C三台服务器分别虚拟出了一个虚拟节点，当然，如果你需要，也可以虚拟出更多的虚拟节点。引入虚拟节点的概念后，缓存的分布就均衡多了，上图中，1号、3号图片被缓存在服务器A中，5号、4号图片被缓存在服务器B中，6号、2号图片被缓存在服务器C中，如果你还不放心，可以虚拟出更多的虚拟节点，以便减小hash环偏斜所带来的影响，虚拟节点越多，hash环上的节点就越多，缓存被均匀分布的概率就越大。

六、实现

package hash;

import hash.Shard.Node;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.SortedMap;
import java.util.TreeMap;

@SuppressWarnings("hiding")
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;
    
    @SuppressWarnings("static-access")
    public Shard(List<Node> shards) {
        super();
        this.shards = shards;
        init();
    }

    public static void main(String[] args) {
        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");
        shards.add(s1);
        shards.add(s2);
        shards.add(s3);
        shards.add(s4);
        Shard<Node> sh = new 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(s4);
        sh.addS(s4);
        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);
        SortedMap<Long, Node> between;
        if(head.size()==0){
            between = treeKey.tailMap(nodes.lastKey());
        }else{
            Long begin = head.lastKey();
            between = treeKey.subMap(begin, false, lg, true);
        }
        nodes.put(lg, s);
        for(Iterator<Long> it=between.keySet().iterator();it.hasNext();){
            Long lo = it.next();
            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));
            SortedMap<Long, Node> between;
            if(head.size()==0){
                between = treeKey.tailMap(nodes.lastKey());
            }else{
                Long begin = head.lastKey();
                Long end = tail.firstKey();
                between = treeKey.subMap(begin, false, end, true);//在s节点的第i个虚拟节点的所有key的集合
            }
            nodes.remove(tail.firstKey());//从nodes中删除s节点的第i个虚拟节点
            for(Iterator<Long> it = between.keySet().iterator();it.hasNext();){
                Long lo = it.next();
                if (tail.size() == 0) {
                    // 如果是尾节点，则关联到首接点上
                    treeKey.put(lo, nodes.firstEntry().getValue());
                    System.out.println("hash("+lo+")改变到->"+nodes.firstEntry().getValue());
                } else {
                    treeKey.put(lo, tail.get(tail.firstKey()));
                    System.out.println("hash("+lo+")改变到->"+tail.get(tail.firstKey()));
                }
            }
        }
        
    }

    //映射key到真实节点
    public void keyToNode(String key){
        Long hashKey = hash(key);
        SortedMap<Long, Node> tail = nodes.tailMap(hashKey); // 沿环的顺时针找到一个虚拟节点
        // 如果是尾节点
        if (tail.size() == 0) {
            // 映射节点为首节点
            treeKey.put(hashKey, nodes.firstEntry().getValue());
            System.out.println(key+"(hash: "+hashKey+")连接到主机->"+nodes.firstEntry().getValue());
            return;
        }
        treeKey.put(hashKey, tail.get(tail.firstKey()));
        System.out.println(key+"(hash:"+hashKey+")连接到主机->"+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);
            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;
        }
    }
}

参考：

http://www.zsythink.net/archives/1182/