Add the implementation......

Author: adohe

.gitignore

@@ -10,3 +10,6 @@
 
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*
+
+*.iml
+.idea

pom.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.xqbase.java</groupId>
+    <artifactId>hash</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.8.2</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>19.0</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>

src/main/java/com/xqbase/java/hash/Hashing.java

@@ -0,0 +1,55 @@
+package com.xqbase.java.hash;
+
+/**
+ * Jump Consistent Hash implementation.
+ */
+public final class Hashing {
+
+    /**
+     * 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>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) {
+        if (buckets <= 0) {
+            throw new IllegalArgumentException("buckets must be positive");
+        }
+        LinearCongruentialGenerator generator = new LinearCongruentialGenerator(input);
+        int candidate = 0;
+        int next;
+
+        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);
+        }
+    }
+}

src/test/java/com/xqbase/java/hash/HashingTest.java

@@ -0,0 +1,79 @@
+package com.xqbase.java.hash;
+
+import com.google.common.util.concurrent.AtomicLongMap;
+import junit.framework.TestCase;
+
+import java.util.Random;
+
+/**
+ * Consistent Hash Test Case.
+ */
+public class HashingTest extends TestCase {
+
+    private static final int ITERS = 10000;
+    private static final int MAX_SHARDS = 500;
+
+    public void testConsistentHash_correctness() {
+        long[] interestingValues = { -1, 0, 1, 2, Long.MAX_VALUE, Long.MIN_VALUE };
+        for (long h : interestingValues) {
+            checkConsistentHashCorrectness(h);
+        }
+        Random r = new Random(7);
+        for (int i = 0; i < 20; i++) {
+            checkConsistentHashCorrectness(r.nextLong());
+        }
+    }
+
+    private void checkConsistentHashCorrectness(long hashCode) {
+        int last = 0;
+        for (int shards = 1; shards <= 100000; shards++) {
+            int b = Hashing.consistentHash(hashCode, shards);
+            if (b != last) {
+                assertEquals(shards - 1, b);
+                last = b;
+            }
+        }
+    }
+
+    public void testConsistentHash_probabilities() {
+        AtomicLongMap<Integer> map = AtomicLongMap.create();
+        Random r = new Random(9);
+        for (int i = 0; i < ITERS; i++) {
+            countRemaps(r.nextLong(), map);
+        }
+        for (int shard = 2; shard <= MAX_SHARDS; shard++) {
+            // Rough: don't exceed 1.2x the expected number of remaps by more than 20
+            assertTrue(map.get(shard) <= 1.2 * ITERS / shard + 20);
+        }
+    }
+
+    private void countRemaps(long h, AtomicLongMap<Integer> map) {
+        int last = 0;
+        for (int shards = 2; shards <= MAX_SHARDS; shards++) {
+            int chosen = Hashing.consistentHash(h, shards);
+            if (chosen != last) {
+                map.incrementAndGet(shards);
+                last = chosen;
+            }
+        }
+    }
+
+    /**
+     * Check a few "golden" values to see that implementations across languages
+     * are equivalent.
+     */
+    public void testConsistentHash_linearCongruentialGeneratorCompatibility() {
+        int[] golden100 =
+                { 0, 55, 62, 8, 45, 59, 86, 97, 82, 59,
+                        73, 37, 17, 56, 86, 21, 90, 37, 38, 83 };
+        for (int i = 0; i < golden100.length; i++) {
+            assertEquals(golden100[i], Hashing.consistentHash(i, 100));
+        }
+        assertEquals(6, Hashing.consistentHash(10863919174838991L, 11));
+        assertEquals(3, Hashing.consistentHash(2016238256797177309L, 11));
+        assertEquals(5, Hashing.consistentHash(1673758223894951030L, 11));
+        assertEquals(80343, Hashing.consistentHash(2, 100001));
+        assertEquals(22152, Hashing.consistentHash(2201, 100001));
+        assertEquals(15018, Hashing.consistentHash(2202, 100001));
+    }
+}