redis哈希环，如何解决mget问题？
为了解决redis存储数据量问题，通常会用若干台服务器形成一个环，然后根据数据的key，哈希得到一个值，根据这个哈希值将数据存储到某一台服务器。
现在我遇到一个问题：jedis又一个方法是mget，参数是一批key，然后根据这一批key从服务器获得对应的一批value。如果是根据key的哈希值来确定服务器，那么是不是意味着无法通过一次网络访问，来批量获得这一批value？比如说我有100个key，需要对应的value，如果一次获取，可能耗时为1ms；如果每次只能单个，可能就要100ms；是不是当一次请求耗时主要消耗在redis内部而不是网络传输上的时候，用哈希环比较划算？还望相关经验人士分享解决下小弟的问题。
添加评论 分享

赞同
2
反对，不会显示你的姓名
谢凌君
蒋川、吴健 赞同
哈希环指的是一致性哈希算法，用来解决key在多个服务器上平均分布和在服务失效时的平滑迁移问题。这个和mget的网络访问应该属于不同层面的问题。
你的实际问题是，怎样同时取多个redis上多个key。将多个key按照一致性哈希分成n组，同时对n个redis发送mget命令，来取得对应组中的key即可，然后再合并多组回应。
实际的网络开销也只有一个round trip的时间(时间取决于最慢的那个redis)
至于怎么实现，可以自己在client端封装一个智能的mget，也可以实现一个redis的中间件，解决redis集群的路由问题。
当然，redis 3.0的rc1提供了redis cluster的直接支持，建议参考官方文档，避免自己造轮子
Partitioning: how to split data among multiple Redis instances.
Redis cluster tutorial


一致性Hash算法在Redis的使用
时间 2014-12-31 15:21:00 博客园-原创精华区
原文
由于redis是单点，但是项目中不可避免的会使用多台Redis缓存服务器，那么怎么把缓存的Key均匀的映射到多台Redis服务器上，且随着缓存服务器的增加或减少时做到最小化的减少缓存Key的命中率呢？这样就需要我们自己实现分布式。

Memcached对大家应该不陌生，通过把Key映射到Memcached Server上，实现快速读取。我们可以动态对其节点增加，并未影响之前已经映射到内存的Key与memcached Server之间的关系，这就是因为使用了一致性哈希。因为Memcached的哈希策略是在其客户端实现的，因此不同的客户端实现也有区别，以Spymemcache、Xmemcache为例，都是使用了KETAMA作为其实现。

因此，我们也可以使用一致性hash算法来解决Redis分布式这个问题。在介绍一致性hash算法之前，先介绍一下我之前想的一个方法，怎么把Key均匀的映射到多台Redis Server上。

由于LZ水平有限且对Redis研究的不深，文中有写的不对的地方请指正。

方案一

该方案是前几天想的一个方法，主要思路是通过对缓存Key中的字母和数字的ascii码值求sum，该sum值对Redis Server总数取余得到的数字即为该Key映射到的Redis Server，该方法有一个很大的缺陷就是当Redis Server增加或减少时，基本上所有的Key都映射不到对应的的Redis Server了。代码如下：

/// <summary> 

 /// 根据缓存的Key映射对应的Server 

 /// </summary> 

 /// <param name="Key"></param> 

 /// <returns></returns> 

 public static RedisClient GetRedisClientByKey(string Key) 

 { 

 List<RedisClientInfo> RedisClientList = new List<RedisClientInfo>(); 

 RedisClientList.Add(new RedisClientInfo() { Num = 0, IPPort = "127.0.0.1:6379" }); 

 RedisClientList.Add(new RedisClientInfo() { Num = 1, IPPort = "127.0.0.1:9001" }); 

 char[] charKey = Key.ToCharArray(); 

 //记录Key中的所有字母与数字的ascii码和 

 int KeyNum = 0; 

 //记录余数 

 int Num = 0; 

 foreach (var c in charKey) 

 { 

 if ((c >= 'a' && 'z' >= c) || (c >= 'A' && 'Z' >= c)) 

 { 

 System.Text.ASCIIEncoding asciiEncoding = new System.Text.ASCIIEncoding(); 

 KeyNum = KeyNum + (int)asciiEncoding.GetBytes(c.ToString())[0]; 

 } 

 if (c >= '1' && '9' >= c) 

 { 

 KeyNum += Convert.ToInt32(c.ToString()); 

 } 

 } 

 Num = KeyNum % RedisClientList.Count; 

 return new RedisClient(RedisClientList.Where(it => it.Num == Num).First().IPPort); 

 } 

 //Redis客户端信息 

 public class RedisClientInfo 

 { 

 //Redis Server编号 

 public int Num { get; set; } 

 //Redis Server IP地址和端口号 

 public string IPPort { get; set; } 

 }

方案二

1、分布式实现

通过key做一致性哈希，实现key对应redis结点的分布。

一致性哈希的实现：

hash值计算：通过支持MD5与MurmurHash两种计算方式，默认是采用MurmurHash，高效的hash计算。
一致性的实现：通过java的TreeMap来模拟环状结构，实现均匀分布
什么也不多说了，直接上代码吧，LZ也是只知道点皮毛，代码中还有一些看不懂的地方，留着以后慢慢琢磨

public class KetamaNodeLocator 

 { 

 //原文中的JAVA类TreeMap实现了Comparator方法，这里我图省事，直接用了net下的SortedList，其中Comparer接口方法） 

 private SortedList<long, string> ketamaNodes = new SortedList<long, string>(); 

 private HashAlgorithm hashAlg; 

 private int numReps = 160; 

 //此处参数与JAVA版中有区别，因为使用的静态方法，所以不再传递HashAlgorithm alg参数 

 public KetamaNodeLocator(List<string> nodes/*，int nodeCopies*/) 

 { 

 ketamaNodes = new SortedList<long, string>(); 

 //numReps = nodeCopies; 

 //对所有节点，生成nCopies个虚拟结点 

 foreach (string node in nodes) 

 { 

 //每四个虚拟结点为一组 

 for (int i = 0; i < numReps / 4; i++) 

 { 

 //getKeyForNode方法为这组虚拟结点得到惟一名称 

 byte[] digest = HashAlgorithm.computeMd5(node + i); 

 /** Md5是一个16字节长度的数组，将16字节的数组每四个字节一组，分别对应一个虚拟结点，这就是为什么上面把虚拟结点四个划分一组的原因*/ 

 for (int h = 0; h < 4; h++) 

 { 

 long m = HashAlgorithm.hash(digest, h); 

 ketamaNodes[m] = node; 

 } 

 } 

 } 

 } 

 public string GetPrimary(string k) 

 { 

 byte[] digest = HashAlgorithm.computeMd5(k); 

 string rv = GetNodeForKey(HashAlgorithm.hash(digest, 0)); 

 return rv; 

 } 

 string GetNodeForKey(long hash) 

 { 

 string rv; 

 long key = hash; 

 //如果找到这个节点，直接取节点，返回 

 if (!ketamaNodes.ContainsKey(key)) 

 { 

 //得到大于当前key的那个子Map，然后从中取出第一个key，就是大于且离它最近的那个key 说明详见: http://www.javaeye.com/topic/684087 

 var tailMap = from coll in ketamaNodes 

 where coll.Key > hash 

 select new { coll.Key }; 

 if (tailMap == null || tailMap.Count() == 0) 

 key = ketamaNodes.FirstOrDefault().Key; 

 else 

 key = tailMap.FirstOrDefault().Key; 

 } 

 rv = ketamaNodes[key]; 

 return rv; 

 } 

 } 

 public class HashAlgorithm 

 { 

 public static long hash(byte[] digest, int nTime) 

 { 

 long rv = ((long)(digest[3 + nTime * 4] & 0xFF) << 24) 

 | ((long)(digest[2 + nTime * 4] & 0xFF) << 16) 

 | ((long)(digest[1 + nTime * 4] & 0xFF) << 8) 

 | ((long)digest[0 + nTime * 4] & 0xFF); 

 return rv & 0xffffffffL; /* Truncate to 32-bits */ 

 } 

 /** 

 * Get the md5 of the given key. 

 */ 

 public static byte[] computeMd5(string k) 

 { 

 MD5 md5 = new MD5CryptoServiceProvider(); 

 byte[] keyBytes = md5.ComputeHash(Encoding.UTF8.GetBytes(k)); 

 md5.Clear(); 

 //md5.update(keyBytes); 

 //return md5.digest(); 

 return keyBytes; 

 } 

 }

2、分布式测试

1、假设有两个server：0001和0002，循环调用10次看看Key值能不能均匀的映射到server上，代码如下：

static void Main(string[] args) 

 { 

 //假设的server 

 List<string> nodes = new List<string>() { "0001","0002" }; 

 KetamaNodeLocator k = new KetamaNodeLocator(nodes); 

 string str = ""; 

 for (int i = 0; i < 10; i++) 

 { 

 string Key="user_" + i; 

 str += string.Format("Key:{0}分配到的Server为：{1}\n\n", Key, k.GetPrimary(Key)); 

 } 

 Console.WriteLine(str); 

 Console.ReadLine(); 

 }

程序运行两次的结果如下，发现Key基本上均匀的分配到Server节点上了。


2、我们在添加一个0003的server节点，代码如下：

static void Main(string[] args) 

 { 

 //假设的server 

 List<string> nodes = new List<string>() { "0001","0002" ,"0003"}; 

 KetamaNodeLocator k = new KetamaNodeLocator(nodes); 

 string str = ""; 

 for (int i = 0; i < 10; i++) 

 { 

 string Key="user_" + i; 

 str += string.Format("Key:{0}分配到的Server为：{1}\n\n", Key, k.GetPrimary(Key)); 

 } 

 Console.WriteLine(str); 

 Console.ReadLine(); 

 }

程序运行两次的结果如下：


对比第一次的运行结果发现只有user_5,user_7,user_9的缓存丢失，其他的缓存还可以命中。

3、我们去掉server 0002，运行两次的结果如下:


对比第二次和本次运行结果发现 user_0,user_1,user_6 缓存丢失。

结论

通过一致性hash算法可以很好的解决Redis分布式的问题，且当Redis server增加或减少的时候，之前存储的缓存命中率还是比较高的。

关于Redis的其他文章