前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >聊聊jump consistent hash

聊聊jump consistent hash

作者头像
code4it
发布2018-09-17 15:21:19
1.5K0
发布2018-09-17 15:21:19
举报
文章被收录于专栏:码匠的流水账

本文主要简介一下jump Consistent hash。

jump consistent hash

jump consistent hash是一致性哈希的一种实现,论文见A Fast, Minimal Memory, Consistent Hash Algorithm 经典的一致性哈希算法来自Consistent Hashing and Random Trees: Distributed Caching Protocols for Relieving Hot Spots on the World Wide Web jump consistent hash与之的主要区别是节点可以扩容,但是不会移除节点。

算法代码

代码语言:javascript
复制
int32_t JumpConsistentHash(uint64_t key, int32_t num_buckets) {
    int64_t b = -1, j = 0;
    while (j < num_buckets) {
        b = j;
        key = key * 2862933555777941757ULL + 1;
        j = (b + 1) * (double(1LL << 31) / double((key >> 33) + 1));
    }
    return b;
}

java实现

guava里头有个现成的实现 guava-22.0-sources.jar!/com/google/common/hash/Hashing.java

代码语言:javascript
复制
/**
   * Assigns to {@code hashCode} a "bucket" in the range {@code [0, buckets)}, in a uniform manner
   * that minimizes the need for remapping as {@code buckets} grows. That is, {@code
   * consistentHash(h, n)} equals:
   *
   * <ul>
   * <li>{@code n - 1}, with approximate probability {@code 1/n}
   * <li>{@code consistentHash(h, n - 1)}, otherwise (probability {@code 1 - 1/n})
   * </ul>
   *
   * <p>This method is suitable for the common use case of dividing work among buckets that meet the
   * following conditions:
   *
   * <ul>
   * <li>You want to assign the same fraction of inputs to each bucket.
   * <li>When you reduce the number of buckets, you can accept that the most recently added buckets
   * will be removed first. More concretely, if you are dividing traffic among tasks, you can
   * decrease the number of tasks from 15 and 10, killing off the final 5 tasks, and {@code
   * consistentHash} will handle it. If, however, you are dividing traffic among servers {@code
   * alpha}, {@code bravo}, and {@code charlie} and you occasionally need to take each of the
   * servers offline, {@code consistentHash} will be a poor fit: It provides no way for you to
   * specify which of the three buckets is disappearing. Thus, if your buckets change from {@code
   * [alpha, bravo, charlie]} to {@code [bravo, charlie]}, it will assign all the old {@code alpha}
   * traffic to {@code bravo} and all the old {@code bravo} traffic to {@code charlie}, rather than
   * letting {@code bravo} keep its traffic.
   * </ul>
   *
   *
   * <p>See the <a href="http://en.wikipedia.org/wiki/Consistent_hashing">Wikipedia article on
   * consistent hashing</a> for more information.
   */
  public static int consistentHash(HashCode hashCode, int buckets) {
    return consistentHash(hashCode.padToLong(), buckets);
  }

  /**
   * Assigns to {@code input} a "bucket" in the range {@code [0, buckets)}, in a uniform manner that
   * minimizes the need for remapping as {@code buckets} grows. That is, {@code consistentHash(h,
   * n)} equals:
   *
   * <ul>
   * <li>{@code n - 1}, with approximate probability {@code 1/n}
   * <li>{@code consistentHash(h, n - 1)}, otherwise (probability {@code 1 - 1/n})
   * </ul>
   *
   * <p>This method is suitable for the common use case of dividing work among buckets that meet the
   * following conditions:
   *
   * <ul>
   * <li>You want to assign the same fraction of inputs to each bucket.
   * <li>When you reduce the number of buckets, you can accept that the most recently added buckets
   * will be removed first. More concretely, if you are dividing traffic among tasks, you can
   * decrease the number of tasks from 15 and 10, killing off the final 5 tasks, and {@code
   * consistentHash} will handle it. If, however, you are dividing traffic among servers {@code
   * alpha}, {@code bravo}, and {@code charlie} and you occasionally need to take each of the
   * servers offline, {@code consistentHash} will be a poor fit: It provides no way for you to
   * specify which of the three buckets is disappearing. Thus, if your buckets change from {@code
   * [alpha, bravo, charlie]} to {@code [bravo, charlie]}, it will assign all the old {@code alpha}
   * traffic to {@code bravo} and all the old {@code bravo} traffic to {@code charlie}, rather than
   * letting {@code bravo} keep its traffic.
   * </ul>
   *
   *
   * <p>See the <a href="http://en.wikipedia.org/wiki/Consistent_hashing">Wikipedia article on
   * consistent hashing</a> for more information.
   */
  public static int consistentHash(long input, int buckets) {
    checkArgument(buckets > 0, "buckets must be positive: %s", buckets);
    LinearCongruentialGenerator generator = new LinearCongruentialGenerator(input);
    int candidate = 0;
    int next;

    // Jump from bucket to bucket until we go out of range
    while (true) {
      next = (int) ((candidate + 1) / generator.nextDouble());
      if (next >= 0 && next < buckets) {
        candidate = next;
      } else {
        return candidate;
      }
    }
  }

/**
   * Linear CongruentialGenerator to use for consistent hashing. See
   * http://en.wikipedia.org/wiki/Linear_congruential_generator
   */
  private static final class LinearCongruentialGenerator {
    private long state;

    public LinearCongruentialGenerator(long seed) {
      this.state = seed;
    }

    public double nextDouble() {
      state = 2862933555777941757L * state + 1;
      return ((double) ((int) (state >>> 33) + 1)) / (0x1.0p31);
    }
  }

使用实例

代码语言:javascript
复制
    @Test
    public void testJumpHash(){
        List<String> nodes = Arrays.asList("ins1","ins2","ins3","ins4");
        List<String> keys = Arrays.asList("key1","key2","key3","key4");
        keys.stream().forEach(e -> {
            int bucket = Hashing.consistentHash(Hashing.md5().hashString(e, Charsets.UTF_8), nodes.size());
            String node = nodes.get(bucket);
            System.out.println(e + " >> " + node);
        });
    }

doc

  • A Fast, Minimal Memory, Consistent Hash Algorithm
  • 一个速度快内存占用小的一致性哈希算法
  • jump Consistent hash:零内存消耗,均匀,快速,简洁,来自Google的一致性哈希算法
本文参与 腾讯云自媒体同步曝光计划,分享自微信公众号。
原始发表:2017-11-11,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 码匠的流水账 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • jump consistent hash
  • 算法代码
  • java实现
  • 使用实例
  • doc
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档