一致性hash算法

1.特点以及解决的问题

特点,节点扩容或者缩减时相应的数据变化减少,避免数据大量迁移

目前主要应用于分布式缓存系统中

一致性hash可以用来有效解决分布式存储结构下动态增加或者删除节点带来的数据大量迁移问题。

2.对比传统的hash算法

传统的hash算法利用( hash(key) mod(N) ) 进行请求映射，也就是需要按照hash函数后的值对N求出余数i 然后按照i进行请求

当增节点，计算算法改变为 hash(key) mod(N+1) 意味着对N+1进行求余，同样的key请求落到了不同的节点上，影响的机器数为N，

数据-节点映射变动率为 N/(N+1) 不可谓不大。

一致性hash算法:

• 1、首先，我们将hash算法的值域映射成一个具有2的32次方个桶的空间中，即0~（2的32次方）-1的数字空间。现在我们可以将这些数字头尾相连，组合成一个闭合的环形。
• 2、每一个缓存key都可以通过Hash算法转化为一个32位的二进制数，也就对应着环形空间的某一个缓存区。我们把所有的缓存key映射到环形空间的不同位置。
• 3、我们的每一个缓存节点也遵循同样的Hash算法，比如利用IP或者主机名做Hash，映射到环形空间当中，如下图

怎么按照key找到对应的缓存节点取数?

很简单，每一个key的顺时针方向最近节点，就是key所归属的缓存节点。所以图中key1存储于node1，key2，key3存储于node2，key4存储于node3。

节点增减时会发生什么情况?

增加节点

增加节点时如上图 增加node4节点，按照原则key2 数据重新映射到node4节点上key3则没有产生变化

所以只需要改变key2数据的从属即可重新达到平衡

删除节点

如上:把node3节点删除，按照规则key4数据的节点从属将更改为node1节点，其它的数据则没有收到影响。

所以此时只需要改变key4数据的从属，数据就可以重新达到平衡。此时数据受影响率为1/4。

其它情况，数据分布不均匀

如果出现分布不均匀的情况怎么办？

由于是通过hash计算

一致性hash算法的结果相比传统hash求余算法已经进步很多，但是出现分布不均匀的情况会有问题。比如下图这样，按顺时针规则，所有的key都归属于统一个节点。

为了缓解这种数据不均匀导致的热点问题引入了

一致性hash算法+虚拟节点

进行解决

tips:虚拟节点越多，分布越均匀。使用一致性hash算法+虚拟节点这种情况下，缓存节点从3个变成4个，缓存失效率为25%，而且每个节点都平均的承担了压力。

问题: 虚拟节点到实际节点的映射?

首先基于实际节点的个数以及需要虚拟出来的节点个数进行分配，如3个真实节点总共需要虚拟出6个节点，假如平均分配后每个节点两个虚拟节点

假如真实节点名称Node1 则虚拟节点可以命名为node1-1 , node1-2 key映射落在这两个虚拟节点实际是落在node1真实节点。

通过增加虚拟节点的方法解决了数据均匀分配的问题。增加了一个从虚拟节点到真实节点的步骤。

一致性hash算法 Java实现

原理理解了，实现并不难，主要是一些细节：

• 1、hash算法的选择。
  • Java代码不要使用hashcode函数，这个函数结果不够散列，而且会有负值需要处理。
  • 这种计算Hash值的算法有很多，比如CRC32HASH、FNV132HASH、KETAMAHASH等，其中KETAMAHASH是默认的MemCache推荐的一致性Hash算法，用别的Hash算法也可以，比如FNV132_HASH算法的计算效率就会高一些。
• 2、数据结构的选择。根据算法原理，我们的算法有几个要求：
  • 要能根据hash值排序存储
  • 排序存储要被快速查找 （List不行）
  • 排序查找还要能方便变更 （Array不行）

另外，由于二叉树可能极度不平衡。所以采用红黑树是最稳妥的实现方法。Java中直接使用TreeMap即可。

package org.apache.dolphinscheduler.server.master.dispatch.host.assign;

import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.SortedMap;
import java.util.TreeMap;

/**
 * 一致性hash
 *

 * <p>
 * 《普通hash方法》
 * NODE节点 : 有序数组或list列表, 如缓存redis服务器ip列表;
 * 数据节点 : 支持获取hashCode, 如redis key;
 * 映射方法 : key.hashCode % NODE.size
 * 优点 : 简单,高效;
 * 缺点 : NODE增减, 所有映射都会失效, 如redis服务某一个节点宕机, 所有持久化文件要做数据迁移, 其他缓存全部失效;
 * <p>
 * 《一致性hash算法》
 * hash环 : 抽象概念, 一张巨大的hash环装链表;
 * NODE节点 : 对NODE进行hash计算, 散列对应到hash环上某一个位置;
 * NODE节点-虚拟节点 : 对每个NODE节点生成一定量虚拟节点, 每个NODE虚拟节点都对关联到一个真实NODE节点, 对虚拟节点进行hash计算, 散列对应到hash换上某一个位置;
 * 数据节点 : 对数据进行hash计算, 对应到hash环上某一个位置, 然后顺时针找到最近的NODE节点, 命中然后存储;
 * <p>
 * 优点 : NODE增减, 改节点原NODE节点的命中会漂移到相邻的后一个NODE节点, 不会造成整体失效, 只会影响其中一个节点;
 * 缺点 : 理解和维护起来, 需要一定学习成本;
 * 缺点(已解决) : NODE其中一个节点失效, 该节点数据瞬间映射到下一个节点, 会造成例如 “缓存雪崩”现象, 在此引入NODE虚拟节点, 可以将该节点数据, 平衡的散列到其他存活的NODE节点中;
 * <p>
 * --- 0 --------- node1_1 ----------- node2_2 --------- node1_2 ------ node2_1 ------ 2^64|0 ---
 * -------- key1 --------- key02 ---------
 */

public class ConsistencyHashUtil {


   private List<String> shardNodes;
   private final int NODE_NUM = 1000;
   private TreeMap<Long, String> virtualHash2RealNode = new TreeMap<Long, String>();

   /**
    * init consistency hash ring, put virtual node on the 2^64 ring
    */
   public void initVirtual2RealRing(List<String> shards) {
      this.shardNodes = shards;
      for (String node : shardNodes) {
         for (int i = 0; i < NODE_NUM; i++) {
            long hashCode = hash("SHARD-" + node + "-NODE-" + i);
            virtualHash2RealNode.put(hashCode, node);
         }
      }
   }

   /**
    * get real node by key's hash on the 2^64
    */
   public String getShardInfo(String key) {
      long hashCode = hash(key);
      SortedMap<Long, String> tailMap = virtualHash2RealNode.tailMap(hashCode);
      if (tailMap.isEmpty()) {
         return virtualHash2RealNode.get(virtualHash2RealNode.firstKey());
      }
      return virtualHash2RealNode.get(tailMap.firstKey());
   }

   /**
    * prinf ring virtual node info
    */
   public void printMap() {
      System.out.println(virtualHash2RealNode);
   }

   /**
    * MurMurHash算法，是非加密HASH算法，性能很高，
    * 比传统的CRC32,MD5，SHA-1（这两个算法都是加密HASH算法，复杂度本身就很高，带来的性能上的损害也不可避免）
    * 等HASH算法要快很多，而且据说这个算法的碰撞率很低.
    * http://murmurhash.googlepages.com/
    */
   public 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);
         // for big-endian version, do this first:
         // finish.position(8-buf.remaining());
         finish.put(buf).rewind();
         h ^= finish.getLong();
         h *= m;
      }
      h ^= h >>> r;
      h *= m;
      h ^= h >>> r;
      buf.order(byteOrder);
      return h;
   }

   /**
    * get hash code on 2^32 ring (md5散列的方式计算hash值)
    *
    * @param digest
    * @param nTime
    * @return
    */
   public static long hash2(String key) {
      // md5 byte
      MessageDigest md5;
      try {
         md5 = MessageDigest.getInstance("MD5");
      } catch (NoSuchAlgorithmException e) {
         throw new RuntimeException("MD5 not supported", e);
      }
      md5.reset();
      byte[] keyBytes = null;
      try {
         keyBytes = key.getBytes("UTF-8");
      } catch (UnsupportedEncodingException e) {
         throw new RuntimeException("Unknown string :" + key, e);
      }
      md5.update(keyBytes);
      byte[] digest = md5.digest();
      // hash code, Truncate to 32-bits
      long hashCode = ((long) (digest[3] & 0xFF) << 24)
            | ((long) (digest[2] & 0xFF) << 16)
            | ((long) (digest[1] & 0xFF) << 8)
            | (digest[0] & 0xFF);
      long truncateHashCode = hashCode & 0xffffffffL;
      return truncateHashCode;
   }

   public static void main(String[] args) {
      List<String> shards = new ArrayList<String>();
      shards.add("consumer-uuid-2");
      shards.add("consumer-uuid-1");
      ConsistencyHashUtil sh = new ConsistencyHashUtil();
      sh.initVirtual2RealRing(shards);
      sh.printMap();
      int consumer1 = 0;
      int consumer2 = 0;
      for (int i = 0; i < 10000; i++) {
         String key = "consumer" + i;
         System.out.println(hash(key) + ":" + sh.getShardInfo(key));
         if ("consumer-uuid-1".equals(sh.getShardInfo(key))) {
            consumer1++;
         }
         if ("consumer-uuid-2".equals(sh.getShardInfo(key))) {
            consumer2++;
         }
      }
      System.out.println("consumer1:" + consumer1);
      System.out.println("consumer2:" + consumer2);
   }
}