【分布式系列】一致性哈希原理

概述

一致性是传统 hash 算法的增强版。

多用于分布式数据存储场景，在集群节点数量发生变化时，提升集群适应变化的能力。

使用场景

• 传统Hash，当节点数量发生变化，需要调整的数据比较多。
• 一致性Hash，引入哈希环的概念。如果A节点宕机，顺时针找到下一个服务节点。如果需要新增D节点，原来分摊给A节点的数据，部分分担给D节点。会造成数据倾斜。
• 引入虚拟节点。

设计方案

• 给每个真实节点创建n个虚拟节点，如果真实节点是3个，虚拟副本数量是100个，会创造300个虚拟节点，落在hash环中。每增加一个节点，都是创建100个虚拟副本，添加在Hash环中。
• 当新增数据的数据，会计算Hash值，获得一个最近的顺时针节点，根据虚拟节点获取到真实节点。

代码实现

public class ConsistentHash<T> implements Serializable{
   private static final long serialVersionUID = 1L;
   
   /** Hash计算对象，用于自定义hash算法 */
   Hash32<Object> hashFunc;
   /** 复制的节点个数 */
   private final int numberOfReplicas;
   /** 一致性Hash环 */
   private final SortedMap<Integer, T> circle = new TreeMap<>();
   
   /**
    * 构造，使用Java默认的Hash算法
    * @param numberOfReplicas 复制的节点个数，增加每个节点的复制节点有利于负载均衡
    * @param nodes 节点对象
    */
   public ConsistentHash(int numberOfReplicas, Collection<T> nodes) {
      this.numberOfReplicas = numberOfReplicas;
      this.hashFunc = key -> {
         //默认使用FNV1hash算法
         return HashUtil.fnvHash(key.toString());
      };
      //初始化节点
      for (T node : nodes) {
         add(node);
      }
   }

   /**
    * 构造
    * @param hashFunc hash算法对象
    * @param numberOfReplicas 复制的节点个数，增加每个节点的复制节点有利于负载均衡
    * @param nodes 节点对象
    */
   public ConsistentHash(Hash32<Object> hashFunc, int numberOfReplicas, Collection<T> nodes) {
      this.numberOfReplicas = numberOfReplicas;
      this.hashFunc = hashFunc;
      //初始化节点
      for (T node : nodes) {
         add(node);
      }
   }

   /**
    * 增加节点<br>
    * 每增加一个节点，就会在闭环上增加给定复制节点数<br>
    * 例如复制节点数是2，则每调用此方法一次，增加两个虚拟节点，这两个节点指向同一Node
    * 由于hash算法会调用node的toString方法，故按照toString去重
    * @param node 节点对象
    */
   public void add(T node) {
      for (int i = 0; i < numberOfReplicas; i++) {
         circle.put(hashFunc.hash32(node.toString() + i), node);
      }
   }

   /**
    * 移除节点的同时移除相应的虚拟节点
    * @param node 节点对象
    */
   public void remove(T node) {
      for (int i = 0; i < numberOfReplicas; i++) {
         circle.remove(hashFunc.hash32(node.toString() + i));
      }
   }

   /**
    * 获得一个最近的顺时针节点
    * @param key 为给定键取Hash，取得顺时针方向上最近的一个虚拟节点对应的实际节点
    * @return 节点对象
    */
   public T get(Object key) {
      if (circle.isEmpty()) {
         return null;
      }
      int hash = hashFunc.hash32(key);
      if (false == circle.containsKey(hash)) {
         SortedMap<Integer, T> tailMap = circle.tailMap(hash);  //返回此映射的部分视图，其键大于等于 hash
         hash = tailMap.isEmpty() ? circle.firstKey() : tailMap.firstKey();
      }
      //正好命中
      return circle.get(hash);
   }
}

测试效果，新增的数据会均匀的落到每一个真实节点上。

@Test
public void t1() {
    ConsistentHash<String> consistentHash = new ConsistentHash<>(1000, Arrays.asList("节点1", "节点2", "节点3"));
    int count0 = 0;
    int count1 = 0;
    int count2 = 0;
    for (int i = 0; i < 1000; i++) {
        String nodeName = consistentHash.get(i);
        if (nodeName.equals("节点1")) {
            count0++;
        } else if (nodeName.equals("节点2")) {
            count1++;
        } else {
            count2++;
        }
    }
    System.out.println(count0 + "," + count1 + "," + count2);
}

总结一下

1. 使用Hash值在扩展节点的时候，影响很大。
2. 使用Hash环+就近寻址，会导致数据倾斜，负载不均衡。
3. 使用虚拟节点+Hash环，通过Hash计算，落到虚拟节点上，获取真实节点。保证数据均匀的落在真实节点上，在扩展节点的时候，影响最小。