备份redis

vanadiumlin

浏览: 508774 次
性别:
来自: 广州

最近访客更多访客>>

yefei

wangchunheme

u012363178

痞夫balabala

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

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 博客园-原创精华区
原文 http://www.cnblogs.com/lc-chenlong/p/4195814.html
由于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) <<

          | ((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的其他文章

分享到：