一致性哈希原理及实现

场景描述

假如我们现在有3台缓存服务器，当有一张图片要缓存时，我们希望缓存均匀的分布在3台服务器上，可以使用如下公式来判断要缓存到哪台服务器，

hash(图片名称) % 3 

当我们想增加或减少服务器时，如增加到4台，得到的余数就和之前存放缓存的结果不同了，结果就是所有缓存在一段时间内就算失效了，可能造成系统崩溃。

一致性哈希算法

定义一个由2^32个数组成的环

使用如下公式将服务器A,B,C映射到环上

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

将要缓存的图片也映射到环上

hash（图片名称） %  2^32

从被缓存对象顺时针寻找，遇到的第一个服务器就是当前对象被缓存的服务器。

当我们想增加或减少服务器数量时，如去除服务器B

1,2仍然存储在服务器A,4也仍然存储在服务器C，只有3的存储位置有变化，之前在服务器B，现在要存储到服务器C。
一致性哈希的优点就是当增加或减少服务器时，只有要增加或减少的服务器上的数据有变化，其余服务器不变，对于缓存来说就是并不会造成所有的缓存都失效。

环数据偏斜

服务器列表有可能并不会均匀的映射到环上

这种情况可能大部分数据都会集中到服务器A

如果服务器A出现故障，极端情况下，仍然可能造成系统崩溃，可以使用虚拟节点解决这个问题。

虚拟节点

对每个实际节点复制出一个虚拟节点，一个实际节点可以有多个虚拟节点，虚拟节点越多，数据分布越均匀。

代码实现

import java.util.Collection;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.function.Function;

public class ConsistentHash<T> {

  /**
   * Hash计算对象，用于自定义hash算法
   */
  private Function<String, Integer> 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 = this::fnvHash;
    //初始化节点
    for (T node : nodes) {
      add(node);
    }
  }

  /**
   * 改进的32位FNV算法1
   * https://en.wikipedia.org/wiki/Fowler–Noll–Vo_hash_function
   * @param data 字符串
   * @return hash结果
   */
  private int fnvHash(String data) {
    final int p = 16777619;
    int hash = (int) 2166136261L;
    for (int i = 0; i < data.length(); i++) {
      hash = (hash ^ data.charAt(i)) * p;
    }
    hash += hash << 13;
    hash ^= hash >> 7;
    hash += hash << 3;
    hash ^= hash >> 17;
    hash += hash << 5;
    return Math.abs(hash);
  }

  /**
   * 构造
   *
   * @param hashFunc hash算法对象
   * @param numberOfReplicas 复制的节点个数，增加每个节点的复制节点有利于负载均衡
   * @param nodes 节点对象
   */
  public ConsistentHash(Function<String, Integer> 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.apply(node.toString() + i), node);
    }
  }

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

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

调用

import java.util.List;
import java.util.Map;
import java.util.TreeMap;

public class Client {

  public static void main(String[] args) {
    //物理节点
    List<String> ipNodes = List
        .of("192.168.1.101", "192.168.1.102", "192.168.1.103", "192.168.1.104");
    ConsistentHash<String> consistentHash = new ConsistentHash<>(100, ipNodes);
    // 统计
    statistics(consistentHash, 0, 65536);
    consistentHash = new ConsistentHash<>(10000, ipNodes);
    statistics(consistentHash, 0, 65536);
  }

  private static void statistics(ConsistentHash<String> consistentHash, int objectMin,
      int objectMax) {
    Map<String, Integer> objectNodeMap = new TreeMap<>(); // IP => COUNT
    for (int object = objectMin; object <= objectMax; object++) {
      String nodeIp = consistentHash.get(Integer.toString(object));
      Integer count = objectNodeMap.getOrDefault(nodeIp, 0);
      objectNodeMap.put(nodeIp, count + 1);
    }

    // 打印
    double totalCount = objectMax - objectMin + 1;
    String label = "统计";
    System.out.println("======== " + label + " ========");
    for (Map.Entry<String, Integer> entry : objectNodeMap.entrySet()) {
      long percent = (int) (100 * entry.getValue() / totalCount);
      System.out.println("IP=" + entry.getKey() + ": RATE=" + percent + "%");
    }
  }

}

输出结果为

======== 统计 ========
IP=192.168.1.101: RATE=23%
IP=192.168.1.102: RATE=26%
IP=192.168.1.103: RATE=20%
IP=192.168.1.104: RATE=28%
======== 统计 ========
IP=192.168.1.101: RATE=25%
IP=192.168.1.102: RATE=24%
IP=192.168.1.103: RATE=24%
IP=192.168.1.104: RATE=25%

可以看到虚拟节点越多，数据分布越均匀。

参考

白话解析：一致性哈希算法 consistent hashing
一致性哈希算法的原理与实现