一致性Hash算法在Memcached中的应用

前言

　　你们应该都知道Memcached要想实现分布式只能在客户端来完成,目前比较流行的是经过一致性hash算法来实现.常规的方法是将server的hash值与server的总台数进行求余,即hash%N,这种方法的弊端是当增减服务器时,将会有较多的缓存须要被从新分配且会形成缓存分配不均匀的状况(有可能某一台服务器分配的不少,其它的却不多).

 　　今天分享一种叫作”ketama”的一致性hash算法,它经过虚拟节点的概念和不一样的缓存分配规则有效的抑制了缓存分布不均匀，并最大限度地减小服务器增减时缓存的从新分布。 

实现思路

　　假设咱们如今有N台Memcached的Server,若是咱们用统一的规则对memcached进行Set,Get操做. 使具备不一样key的object很均衡的分散存储在这些Server上,Get操做时也是按一样规则去对应的Server上取出object,这样各个Server之间不就是一个总体了吗?

那究竟是一个什么样的规则?

　　以下图所示,咱们如今有5台(A,B,C,D,E)Memcached的Server,咱们将其串联起来造成一个环形,每一台Server都表明圆环上的一个点,每个点都具备惟一的Hash值,这个圆环上一共有2^32个点.

       那么该如何肯定每台Server具体分布在哪一个点上? 这里咱们经过”Ketama”的Hash算法来计算出每台Server的Hash值,拿到Hash值后就能够对应到圆环上点了.(能够用Server的IP地址做为Hash算法的Key.)

　　这样作的好处是,以下图当我新增Server  F时,那么我只须要将hash值落在C和F之间的object从本来的D上从新分配到F上就能够了,其它的server上的缓存不须要从新分配,而且新增的Server也能及时帮忙缓冲其它Server的压力.

　　到此咱们已经解决了增减服务器时大量缓存须要被从新分配的弊端.那该如何解决缓存分配不均匀的问题呢?由于如今咱们的server只占据圆环上的6个点,而圆环上总共有2^32个点,这极其容易致使某一台server上热点很是多，某一台上热点不多的状况.

　　”虚拟节点”的概念很好的解决了这种负载不均衡的问题.经过将每台物理存在的Server分割成N个虚拟的Server节点(N一般根据物理Server个数来定,这里有个比较好的阈值为250).这样每一个物理Server实际上对应了N个虚拟的节点. 存储点多了,各个Server的负载天然要均衡一些.就像地铁站出口同样,出口越多,每一个出口出现拥挤的状况就会越少.

 　　代码实现:

//保存全部虚拟节点信息, key : 虚拟节点的hash key, value: 虚拟节点对应的真实server
        private Dictionary<uint, string> hostDictionary = new Dictionary<uint, string>();
        //保存全部虚拟节点的hash key, 已按升序排序
        private uint[] ketamaHashKeys = new uint[] { };
        //保存真实server主机地址
        private string[] realHostArr = new string[] { };
        //每台真实server对应虚拟节点个数
        private int VirtualNodeNum = 250;

        public KetamaVirtualNodeInit(string[] hostArr)
        {
            this.realHostArr = hostArr;
            this.InitVirtualNodes();
        }

        /// <summary>
        /// 初始化虚拟节点
        /// </summary>
        private void InitVirtualNodes()
        {
            hostDictionary = new Dictionary<uint, string>();
            List<uint> hostKeys = new List<uint>();
            if (realHostArr == null || realHostArr.Length == 0)
            {
                throw new Exception("不能传入空的Server集合");
            }

            for (int i = 0; i < realHostArr.Length; i++)
            {
                for (int j = 0; j < VirtualNodeNum; j++)
                {
                    byte[] nameBytes = Encoding.UTF8.GetBytes(string.Format("{0}-node{1}", realHostArr[i], j));
                    //调用Ketama hash算法获取hash key
                    uint hashKey = BitConverter.ToUInt32(new KetamaHash().ComputeHash(nameBytes), 0);
                    hostKeys.Add(hashKey);
                    if (hostDictionary.ContainsKey(hashKey))
                    {
                        throw new Exception("建立虚拟节点时发现相同hash key,请检查是否传入了相同Server");
                    }
                    hostDictionary.Add(hashKey, realHostArr[i]);
                }
            }

            hostKeys.Sort();
            ketamaHashKeys = hostKeys.ToArray();
        }

 

一致性hash算法的分配规则

　　到此咱们已经知道了全部虚拟节点的Hash值, 如今让咱们来看下当咱们拿到一个对象时如何存入Server, 或是拿到一个对象的Key时该如何取出对象. 

       Set一个对象时,先将对象的Key做为”Ketama”算法的Key,计算出Hash值后咱们须要作下面几个步骤.

       1:首先检查虚拟节点当中是否有与当前对象Hash值相等的,若有则直接将对象存入那个Hash值相等的节点,后面的步骤就不继续了.

       2:如没有,则找出第一个比当前对象Hash值要大的节点,(节点的Hash值按升序进行排序,圆环上对应按照顺时针来排列),即离对象最近的节点,而后将对象存入该节点.

       3:若是没有找到Hash值比对象要大的Server,证实对象的Hash值是介于最后一个节点和第一个节点之间的,也就是圆环上的E和A之间.这种状况就直接将对象存入第一个节点,即A.

　　代码实现:　　

     /// <summary>
        /// 根据hash key 获取对应的真实Server
        /// </summary>
        /// <param name="hash"></param>
        /// <returns></returns>
        public string GetHostByHashKey(string key)
        {
            byte[] bytes = Encoding.UTF8.GetBytes(key);
            uint hash = BitConverter.ToUInt32(new KetamaHash().ComputeHash(bytes), 0);

            //寻找与当前hash值相等的Server. 
            int i = Array.BinarySearch(ketamaHashKeys, hash);

            //若是i小于零则表示没有hash值相等的虚拟节点
            if (i < 0)
            {
                //将i继续按位求补,获得数组中第一个大于当前hash值的虚拟节点
                i = ~i;

                //若是按位求补后的i大于等于数组的大小,则表示数组中没有大于当前hash值的虚拟节点
                //此时直接取第一个server
                if (i >= ketamaHashKeys.Length)
                {
                    i = 0;
                }
            }

            //根据虚拟节点的hash key 返回对应的真实server host地址
            return hostDictionary[ketamaHashKeys[i]];
        }

 

Get一个对象,一样也是经过”Ketama”算法计算出Hash值,而后与Set过程同样寻找节点,找到以后直接取出对象便可.

那么这个”Ketama”到底长什么样呢,让咱们来看看代码实现.

    /// <summary>
    ///  Ketama hash加密算法
    ///  关于HashAlgorithm参见MSDN连接
    ///  http://msdn.microsoft.com/zh-cn/library/system.security.cryptography.hashalgorithm%28v=vs.110%29.aspx
    /// </summary>
    public class KetamaHash : HashAlgorithm
    {

        private static readonly uint FNV_prime = 16777619;
        private static readonly uint offset_basis = 2166136261;

        protected uint hash;

        public KetamaHash()
        {
            HashSizeValue = 32;
        }

        public override void Initialize()
        {
            hash = offset_basis;
        }

        protected override void HashCore(byte[] array, int ibStart, int cbSize)
        {
            int length = ibStart + cbSize;
            for (int i = ibStart; i < length; i++)
            {
                hash = (hash * FNV_prime) ^ array[i];
            }
        }

        protected override byte[] HashFinal()
        {
            hash += hash << 13;
            hash ^= hash >> 7;
            hash += hash << 3;
            hash ^= hash >> 17;
            hash += hash << 5;
            return BitConverter.GetBytes(hash);
        }
    }

测试性能

最后我把本身参考BeitMemcached写的算法与老代(Discuz!代震军)参考SPYMemcached写的作了一下对比.

源码在后面有下载.

结果:查找5W个key的时间比老代的版本快了100多倍,但在负载均衡方面差了一些. 

测试数据:

　　 1:真实Server都是5台

       2:随机生成5W个字符串key(生成方法直接拿老代的)

       3:虚拟节点都是250个 

       个人版本:

老代的版本:

 

参考资料

BeitMemcached源码

老代: 一致性Hash算法(KetamaHash)的c#实现

总结一致性哈希(Consistent Hashing) 

 

测试代码下载:Memcached-ketama