Jedis中的一致性hash

Jedis中的一致性hash

本文仅供大家参考，不保证正确性，有问题请及时指出

一致性hash就不多说了，网上有很多说的很好的文章，这里说说Jedis中的Shard是如何使用一致性hash的，也为大家在实现一致性hash提供些思路。

首先是hash函数，在Jedis中有两种Hash算法可供选择，分别是MurMurHash和MD5. 按照Jedis的说法MurMur Hash更快，效果更好些。

MurmurHash.java

package redis.clients.util;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

publicclass MurmurHash implements Hashing {

publicstaticint hash(byte[] data, int seed) {

return hash(ByteBuffer.wrap(data), seed);

}

publicstaticint hash(byte[] data, int offset, int length, int seed) {

return hash(ByteBuffer.wrap(data, offset, length), seed);

}

publicstaticint hash(ByteBuffer buf, int seed) {

ByteOrder byteOrder = buf.order();

buf.order(ByteOrder.LITTLE_ENDIAN);

int m = 0x5bd1e995;

int r = 24;

int h = seed ^ buf.remaining();

int k;

while (buf.remaining() >= 4) {

k = buf.getInt();

k *= m;

k ^= k >>> r;

k *= m;

h *= m;

h ^= k;

}

if (buf.remaining() > 0) {

ByteBuffer finish = ByteBuffer.allocate(4).order(

ByteOrder.LITTLE_ENDIAN);

finish.put(buf).rewind();

h ^= finish.getInt();

h *= m;

}

h ^= h >>> 13;

h *= m;

h ^= h >>> 15;

buf.order(byteOrder);

return h;

}

publicstaticlong hash64A(byte[] data, int seed) {

return hash64A(ByteBuffer.wrap(data), seed);

}

publicstaticlong hash64A(byte[] data, int offset, int length, int seed) {

return hash64A(ByteBuffer.wrap(data, offset, length), seed);

}

publicstaticlong hash64A(ByteBuffer buf, int seed) {

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

finish.put(buf).rewind();

h ^= finish.getLong();

h *= m;

}

h ^= h >>> r;

h *= m;

h ^= h >>> r;

buf.order(byteOrder);

return h;

}

publiclong hash(byte[] key) {

return hash64A(key, 0x1234ABCD);

}

publiclong hash(String key) {

return hash(SafeEncoder.encode(key));

}

}

而MD5从java提供的类中即可获得，但是需要将MD5值转换为long类型的常量。

publicinterface Hashing {

publicstaticfinal Hashing MURMUR_HASH = new MurmurHash();

public ThreadLocal<MessageDigest> md5Holder = new ThreadLocal<MessageDigest>();

publicstaticfinal Hashing MD5 = new Hashing() {

publiclong hash(String key) {

return hash(SafeEncoder.encode(key));

}

publiclong hash(byte[] key) {

try {

if (md5Holder.get() == null) {

md5Holder.set(MessageDigest.getInstance("MD5"));

}

} catch (NoSuchAlgorithmException e) {

thrownew IllegalStateException("++++ no md5 algorythm found");

}

MessageDigest md5 = md5Holder.get();

md5.reset();

md5.update(key);

byte[] bKey = md5.digest();

long res = ((long) (bKey[3] & 0xFF) << 24)

| ((long) (bKey[2] & 0xFF) << 16)

| ((long) (bKey[1] & 0xFF) << 8) | (long) (bKey[0] & 0xFF);

return res;

}

};

}

MD5中使用了ThreadLocal，这个就不多说了，网上也有很多相关的blog。或者查看我《如何写性能测试程序》那篇博客。

下面主要说说，Jedis中的一致性Hash部分。

Shard中定义了如下属性：

private TreeMap<Long, S> nodes;

privatefinal Hashing algo;

privatefinal Map<ShardInfo<R>, R> resources = new LinkedHashMap<ShardInfo<R>, R>();

nodes属性类型为TreeMap<Long,S>，表示主机映射。每个主机被Hash后，对应多个Long值，而nodes维护了这些Long值对应的主机。

algo是hash算法，是MurMur或者MD5.

resources 完成主机信息和实际链接（Jedis）间的映射。

初始化主机hash如下：

privatevoid initialize(List<S> shards) {

nodes = new TreeMap<Long, S>();

for (int i = 0; i != shards.size(); ++i) {

final S shardInfo = shards.get(i);

if (shardInfo.getName() == null)

for (int n = 0; n < 160 * shardInfo.getWeight(); n++) {

nodes.put(this.algo.hash("SHARD-" + i + "-NODE-" + n), shardInfo);

}

else

for (int n = 0; n < 160 * shardInfo.getWeight(); n++) {

nodes.put(this.algo.hash(shardInfo.getName() + "*" + shardInfo.getWeight() + n), shardInfo);

}

resources.put(shardInfo, shardInfo.createResource());

}

}

在for循环中，遍历主机列表（shards.get(i)），之后对每个主机按照单权重160的比例计算shard值，将shard值和主机信息（shardInfo）放到nodes中，将主机信息（shardInfo）和其对应的链接资源（Jedis）映射放入到resources中。

Weight是权重，用于调节单个主机被映射值个数，如果weight为1，那么当前主机将被映射为160个值，weight为2，当前主机将被映射为320个值，因此weight为2的节点被访问到的概率就会高一些。

获取某个key对应的主机链接：

public S getShardInfo(byte[] key) {

SortedMap<Long, S> tail = nodes.tailMap(algo.hash(key));

if (tail.isEmpty()) {

returnnodes.get(nodes.firstKey());

}

return tail.get(tail.firstKey());

}

在获取key时，先根据key做hash（algo.hash(key)），然后获取node中值大于algo.hash(key)的子树，子树的头结点即为整个子树的最小值，因此选中这个节点做为key的映射节点，取出key值对应的value（hostInfo），之后根据hostInfo，通过resources，获取最终的链接。

public R getShard(byte[] key) {

returnresources.get(getShardInfo(key));

}

当然，一致性hash在存储时，一个key可以对应多个节点，一般这多个节点都是在nodes（MapTree）中连续的，因此，也可以改进这个算法，以便实现多节点存储同一个key的方式。

参考：jedis-2.1.0.jar