# 聊聊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与之的主要区别是节点可以扩容，但是不会移除节点。

## 算法代码

```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实现

```/**
* 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
*/
public static int consistentHash(HashCode hashCode, int 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
*/
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);
}
}```

## 使用实例

```    @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
• 一个速度快内存占用小的一致性哈希算法

0 条评论

• ### 聊聊JerseyEurekaHttpClient的参数

eureka-client-1.8.8-sources.jar!/com/netflix/discovery/shared/transport/jersey/J...

• ### 聊聊openmessaging-java

openmessaging-java/openmessaging-api/src/main/java/io/openmessaging/producer/Pro...

• ### App in Scala

通过查看source code的实现能发现App是一个trait，继承了DelayedInit:

• ### Go进阶40:2FA双因素认证

双重认证(英语：Two-factor authentication,缩写为2FA), 又译为双重验证、双因子认证、双因素认证、二元认证,又称两步骤验证(2-St...

• ### java.util.AbstractCollection[源码解读]

AbstractCollection抽象类继承自Collection接口，它提供了对Collection接口的基本实现，从而使得实现Collection接口的成...

• ### thinkphp5实现微信扫码支付

本文实例为大家分享了thinkphp5微信扫码支付的具体代码，供大家参考，具体内容如下

• ### 打造免费代理IP池

爬虫的过程中，当对方服务器发现你屡次爬取它，可能会遇到被封IP的苦痛，这时IP就应该换啦，打造IP池的意义十分重要，提供免费IP网站有很多，本次用的是西刺代理I...

• ### 如何使用CentOS 7上的Let's Encrypt来保护Nginx

Let's Encrypt是一个新的证书颁发机构（CA），它提供了一种获取和安装免费TLS / SSL证书的简便方法，从而在Web服务器上启用加密的HTTPS。...