【翻譯/介紹】jump Consistent hash:零內存消耗，均勻快速簡潔，來自Google

簡介

jump consistent hash是一種一致性哈希算法, 此算法零內存消耗，均勻分配，快速，而且只有5行代碼。

此算法適合使用在分shard的分佈式存儲系統中 。

此算法的做者是 Google 的 John Lamping 和 Eric Veach，論文原文在 http://arxiv.org/ftp/arxiv/papers/1406/1406.2294.pdf

完整代碼：

JumpConsistentHash

1 2 3 4 5 6 7 8 9

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; }

輸入是一個64位的key，和桶的數量（通常對應服務器的數量），輸出是一個桶的編號。

原理解釋：

下面byron根據論文的推導過程，作個翻譯：

jump consistent hash的設計目標是：

1. 平衡性，把對象均勻地分佈在全部桶中。
2. 單調性，當桶的數量變化時，只須要把一些對象從舊桶移動到新桶，不須要作其它移動。

jump consistent hash的設計思路是：計算當bucket數量變化時，有哪些輸出須要變化。

讓咱們按部就班地思考：

• 記 ch(key,num_buckets) 爲num_buckets時的hash函數。
• 當num_buckets=1時，因爲只有1個桶，顯而易見，對任意k，有ch(k,1)==0。
• 當num_buckets=2時，爲了使hash的結果保持均勻，ch(k,2)的結果應該有佔比1/2的結果保持爲0，有1/2跳變爲1。
• 由此，通常規律是：num_buckets從n變化到n+1後，ch(k,n+1) 的結果中，應該有佔比 n/(n+1) 的結果保持不變，而有 1/(n+1) 跳變爲 n+1。

所以，咱們能夠用一個隨機數生成器，來決定每次要不要跳變，而且讓這個隨機數生成器的狀態僅僅依賴於key。就獲得下面這個初步代碼：

1 2 3 4 5 6 7 8

int ch(int key, int num_buckets) { random.seed(key) ; int b = 0; // This will track ch(key, j +1) . for (int j = 1; j < num_buckets; j ++) { if (random.next() < 1.0/(j+1) ) b = j ; } return b; }

顯而易見，這個算法是O(n)的。同時咱們能夠發現，大多數狀況下b=j 是不會執行的，並且隨着 j 愈來愈大，這個機率愈來愈低。 那麼有沒有辦法根據一個隨機數，直接得出下一個跳變的 j ，下降時間複雜度呢？

ok,請把你的大腦切換到機率論模式。

咱們能夠把 ch(key,bum_buckets) 看作一個隨機變量，

上述算法，追蹤了桶編號的的跳變過程，咱們記上一個跳變結果是b，假設下一個結果以必定機率是 j ，那麼從b+1到j-1，這中間的屢次增長桶都不能跳變。 對於在區間 (b, j) 內的任意整數 i ，j是下一個結果的機率能夠記爲:

P( j>=i ) = P( ch(k,i)==ch(k,b+1) )

其中 ch(k,i)==ch(k,b+1) 意即從b+1到i的過程當中，連續屢次增長桶的時候都沒有跳變，這個機率也就是連續屢次不跳變事件機率的乘積，所以：

P(j>=i) = P( ch(k,b+1)==ch(k,b+2)) * P( ch(k,b+2)==ch(k,b+3)) * P( ch(k,b+3)==ch(k,b+4)) * …… * P( ch(k,i-1)==ch(k,i))

因爲單次不跳變的機率：

P( ch(k,i)==ch(k,i+1) ) = i/(i+1)

因此連續屢次不跳變的機率

P(j>=i) = (b+1)/(b+2) * (b+2)/(b+3) * … * (i-1)/i

先後項分子分母相互抵消，獲得：

P(j>=i) = (b+1)/i

意即：j>=i的機率爲(b+1)/i

此時，咱們取一個在[0,1]區間均勻分佈的隨機數r，規定 r<(b+1)/i，就有j>=i， 因此有 i<(b+1)/r，這樣就獲得了i的上界是 (b+1)/r，因爲對任意的i都要有j>=i，因此 j=floor( (b+1)/r )，這樣咱們用一個隨機數r獲得了j。

所以，代碼能夠改進爲：

1 2 3 4 5 6 7 8 9 10 11

int ch(int key, int num_buckets) { random. seed(key) ; int b = -1; // bucket number before the previous jump int j = 0; // bucket number before the current jump while(j<num_buckets){ b=j; double r=random.next(); // 0<r<1.0 j = floor( (b+1) /r); } return b; }

這個算法的時間複雜度，能夠假設每次r都取0.5，則能夠認爲每次 j=2*j，所以時間複雜度爲O(log(n))。

此處須要一個均勻的僞隨機數生成器，論文中使用了一個64位的線性同餘隨機數生成器。

須要指出的是：不像割環法，jump consistent hash不須要對key作hash，這是因爲jump consistent hash使用內置的僞隨機數生成器，來對每一次key作再hash，（byron的理解：因此結果分佈的均勻性與輸入key的分佈無關，由僞隨機數生成器的均勻性保證）。

各項指標對比分析：

consistent hash的概念出自David Karger的論文，經典而且應用普遍的割環法即出自這篇論文：http://www.ra.ethz.ch/cdstore/www8/data/2181/pdf/pd1.pdf

Karger提出2種實現:

1. 「version A」，用 std::map<uint64_t, int32_t>表示key的hash 到桶id的映射。
2. 「version B」，用 vector<pair<uint64_t, int32_t> >存儲，vector事先排好序，用二分查找。

這兩種實現的查找時間複雜度也都是O(log(n))

jump consistent hash的論文中，用jump consistent hash和Karger的割環算法作了對比，結果以下：

1. key分佈的均勻性

直接從論文中摘錄以下表格：

從標準差(Standard Error)這一列可見，jump consistent hash的均勻性要賽過割環法。

而且顯而易見，jump consistent hash，當 擴/縮容 時，跳變key數量已是理論最少值 1/n。

2. 執行耗時

下面是論文中的執行耗時對比圖，其中k=1000。

3. 內存佔用對比

顯而易見，請自行腦補

4. 初始化耗時對比

顯而易見，請自行腦補

相關連接

在 Hacker News上面的討論：https://news.ycombinator.com/item?id=8136408

這個算法最先在Google的guava庫裏面開源：https://github.com/google/guava/blob/master/guava/src/com/google/common/hash/Hashing.java#L392