redis入门-一致性哈希算法

一、前言

这次我们来讨论下redis cluster依赖的一个核心的算法，一致性哈希算法。我们都知道，redis cluster能够做到动态地扩容，在扩容的过程中如何保证数据的迁移尽可能地小？
如果采用传统的hash(object)%N算法，那么在有机器添加或者删除后，几乎所有数据都要做一次大的迁移，这是我们不希望看到的结果，那么一致性哈希是如何解决这个问题的。

二、标准

一致性hash算法提出了在动态变化的Cache环境中，判定哈希算法好坏的四个定义：

1.平衡性(Balance)：平衡性是指哈希的结果能够尽可能分布到所有的缓冲中去，这样可以使得所有的缓冲空间都得到利用。很多哈希算法都能够满足这一条件。

2.单调性(Monotonicity)：单调性是指如果已经有一些内容通过哈希分派到了相应的缓冲中，又有新的缓冲加入到系统中。哈希的结果应能够保证原有已分配的内容可以被映射到原有的或者新的缓冲中去，而不会被映射到旧的缓冲集合中的其他缓冲区。

3.分散性(Spread)：在分布式环境中，终端有可能看不到所有的缓冲，而是只能看到其中的一部分。当终端希望通过哈希过程将内容映射到缓冲上时，由于不同终端所见的缓冲范围有可能不同，从而导致哈希的结果不一致，最终的结果是相同的内容被不同的终端映射到不同的缓冲区中。这种情况显然是应该避免的，因为它导致相同内容被存储到不同缓冲中去，降低了系统存储的效率。分散性的定义就是上述情况发生的严重程度。好的哈希算法应能够尽量避免不一致的情况发生，也就是尽量降低分散性。

4.负载(Load)：负载问题实际上是从另一个角度看待分散性问题。既然不同的终端可能将相同的内容映射到不同的缓冲区中，那么对于一个特定的缓冲区而言，也可能被不同的用户映射为不同 的内容。与分散性一样，这种情况也是应当避免的，因此好的哈希算法应能够尽量降低缓冲的负荷。

三、图解
一致性哈希图解
这篇文章介绍得很清楚，所以这里就不再重复了。这里只提一点：
虚拟结点的作用：
物理结点普遍的数量不会很多，如果直接以物理结点作为hash，很有可能数据分布会很不均匀，因此这里引入虚拟结点希望把结点的数据增加，最终达到一个尽可能平衡的状态。

• 那么实际redis的虚拟结点复制数量是多少？如何定义一个合理的复制数量
• 新增结点的时候如何把这个新的结点信息同步到各个客户端？这里又会涉及到数据同步的问题，客户端同步到新结点的数据，但是redis的key还没进行迁移，怎么办？

四、源码

HashFunction.java

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/*
 * 实现一致性哈希算法中使用的哈希函数,使用MD5算法来保证一致性哈希的平衡性
 */
public class HashFunction {
    private MessageDigest md5 = null;

    public long hash(String key) {
        if (md5 == null) {
            try {
                md5 = MessageDigest.getInstance("MD5");
            } catch (NoSuchAlgorithmException e) {
                throw new IllegalStateException("no md5 algrithm found");
            }
        }

        md5.reset();
        md5.update(key.getBytes());
        byte[] bKey = md5.digest();
        //具体的哈希函数实现细节--每个字节 & 0xFF 再移位
        long result = ((long) (bKey[3] & 0xFF) << 24)
                | ((long) (bKey[2] & 0xFF) << 16
                | ((long) (bKey[1] & 0xFF) << 8) | (long) (bKey[0] & 0xFF));
        return result & 0xffffffffL;
    }
}

ConsistentHash.java

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;

public class ConsistentHash {
    private final HashFunction hashFunction;
    private final int numberOfReplicas;// 节点的复制因子,实际节点个数 * numberOfReplicas =
    // 虚拟节点个数
    private final SortedMap circle = new TreeMap();// 存储虚拟节点的hash值到真实节点的映射

    public ConsistentHash(HashFunction hashFunction, int numberOfReplicas,
                          Collection nodes) {
        this.hashFunction = hashFunction;
        this.numberOfReplicas = numberOfReplicas;
        for (T node : nodes)
            add(node);
    }

    public void add(T node) {
        for (int i = 0; i < numberOfReplicas; i++)
            // 对于一个实际机器节点 node, 对应 numberOfReplicas 个虚拟节点
            /*
             * 不同的虚拟节点(i不同)有不同的hash值,但都对应同一个实际机器node
             * 虚拟node一般是均衡分布在环上的,数据存储在顺时针方向的虚拟node上
             */
            circle.put(hashFunction.hash(node.toString() + i), node);
    }

    public void remove(T node) {
        for (int i = 0; i < numberOfReplicas; i++)
            circle.remove(hashFunction.hash(node.toString() + i));
    }

    /*
     * 获得一个最近的顺时针节点,根据给定的key 取Hash
     * 然后再取得顺时针方向上最近的一个虚拟节点对应的实际节点
     * 再从实际节点中取得 数据
     */
    public T get(Object key) {
        if (circle.isEmpty())
            return null;
        long hash = hashFunction.hash((String) key);// node 用String来表示,获得node在哈希环中的hashCode
        if (!circle.containsKey(hash)) {//数据映射在两台虚拟机器所在环之间,就需要按顺时针方向寻找机器
            SortedMap tailMap = circle.tailMap(hash);
            hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
        }
        return circle.get(hash);
    }

    public long getSize() {
        return circle.size();
    }

    /*
     * 查看MD5算法生成的hashCode值---表示整个哈希环中各个虚拟节点位置
     */
    public void testBalance(){
        Set sets  = circle.keySet();//获得TreeMap中所有的Key
        SortedSet sortedSets= new TreeSet(sets);//将获得的Key集合排序
        for(Long hashCode : sortedSets){
            System.out.println(hashCode);
        }

        System.out.println("----each location 's distance are follows: ----");
        /*
         * 查看用MD5算法生成的long hashCode 相邻两个hashCode的差值
         */
        Iterator it = sortedSets.iterator();
        Iterator it2 = sortedSets.iterator();
        if(it2.hasNext())
            it2.next();
        long keyPre, keyAfter;
        while(it.hasNext() && it2.hasNext()){
            keyPre = it.next();
            keyAfter = it2.next();
            System.out.println(keyAfter - keyPre);
        }
    }

    public static void main(String[] args) {
        Set nodes = new HashSet();
        nodes.add("A");
        nodes.add("B");
        nodes.add("C");

        ConsistentHash consistentHash = new ConsistentHash(new HashFunction(), 10, nodes);
        consistentHash.add("D");

        System.out.println("hash circle size: " + consistentHash.getSize());
        System.out.println("location of each node are follows: ");
        consistentHash.testBalance();

        //删除结点，rehash
        consistentHash.remove("D");
        consistentHash.testBalance();
    }

}

逻辑很简单，核心关注几点：

• hash算法的实现
• 虚拟结点的数量如何维护
  circle
• 一个key如何定义存放在哪个虚拟结点？
  public T get(Object key)，取顺时针最近的结点
• 虚拟结点和物理结点如何映射？
  circle.put(hashFunction.hash(node.toString() + i), node);其中i是第i个虚拟结点

五、总结

后面把redis的核心源码捞出来好好读读，尽量对redis和redis cluster有一个更深刻的认识。

参考文献

源码分析
https://www.cnblogs.com/hapjin/p/4737207.html
图解
https://blog.csdn.net/cywosp/article/details/23397179