一致性hash算法

参考帖

https://www.cnblogs.com/mushroom/p/4472369.html

hash一致性算法hash函数的一种，他的目的在于实现负载均衡，并且每次访问的目标具有一致性，举个例子来说，根据客户端请求ip，经过hash一致性算法，每次计算出来的一致性hash值都是相同的因此每次

请求的目标主机将是一致的，这种算法广泛使用在负载均衡，数据库水平分表，他的本质在于通过算法的方式计算出key的一致性和唯一性，均衡性

而一致性hash算法的核心在于增加了虚拟节点来尽可能的达到key值投射到目的主机尽量均衡

java实现代码：

http://blog.csdn.net/jerome_s/article/details/52492862

c#实现代码

public class ConsistencyHash
    {

        // 环的所有节点
        private SortedList<long, Object> allNodes = null;
        // 真实服务器节点
        private List<Object> realNodes = new List<object>();
        // 设置虚拟节点数目
        // 太多会影响性能，太少又会导致负载不均衡，一般说来，经验值是150，
        // 当然根据集群规模和负载均衡的精度需求，这个值应该根据具体情况具体对待。
        private int VIRTUAL_NODE_COUNT = 150;

        /**
         * 初始化一致环
         */

        public void init()
        {

            // 加入五台真实服务器
            realNodes.Add("192.168.0.0-服务器0");
            realNodes.Add("192.168.0.1-服务器1");
            realNodes.Add("192.168.0.2-服务器2");
            realNodes.Add("192.168.0.3-服务器3");
            realNodes.Add("192.168.0.4-服务器4");

            // 构造每台真实服务器的虚拟节点
            allNodes = new SortedList<long, object>();
            for (int i = 0; i < realNodes.Count(); i++)
            {
                Object nodeInfo = realNodes[i];
                for (int j = 0; j < VIRTUAL_NODE_COUNT; j++)
                {
                    var cpm = "NODE-" + i + "-VIRTUAL-" + j;
                    var md5 = computeMd5(cpm);
                    var hashVal = hash(md5, 0);
                    allNodes.Add(hashVal, nodeInfo);

                    Console.WriteLine(string.Format("{0}	{1}", cpm,hashVal));
                }
            }
        }

        /**
         * 计算MD5值
         */

        public 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^32把节点分布到环上面
         *
         * @param digest
         * @param nTime
         * @return
         */

        public 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)
                      | (digest[0 + nTime*4] & 0xFF);

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


        /**
         * 根据key的hash值取得服务器节点信息
         *
         * @param hash
         * @return
         */

        public Object getNodeInfo(long hash)
        {

            string rv;
            long key = hash;
            //如果找到这个节点，直接取节点，返回   
            if (!allNodes.ContainsKey(key))
            {
                //得到大于当前key的那个子Map，然后从中取出第一个key，就是大于且离它最近的那个key 说明详见: http://www.javaeye.com/topic/684087
                var tailMap = from coll in allNodes
                    where coll.Key > hash
                    select new {coll.Key};
                if (tailMap == null || tailMap.Count() == 0)
                    key = allNodes.FirstOrDefault().Key;
                else
                    key = tailMap.FirstOrDefault().Key;
            }
            return allNodes[key];
        }

    }

示例使用代码

static void Main(string[] args)
        {
            ConsistencyHash consistencyHash = new ConsistencyHash();
            consistencyHash.init();

            int _0 = 0;
            int _1 = 0;
            int _2 = 0;
            int _3 = 0;
            int _4 = 0;

            Random ran = new Random();
            for (int i = 0; i < 50000; i++)
            {
                // 随便取一个数的md5
                byte[] ranNum = consistencyHash.computeMd5(i.ToString());

                // 分配到随即的hash环上面
                long key = consistencyHash.hash(ranNum, 2);
                // long key = consistencyHash.hash(ranNum, ran.nextInt(consistencyHash.VIRTUAL_NODE_COUNT));

                // 获取他所属服务器的信息
                // System.out.println(consistencyHash.getNodeInfo(key));
                if (consistencyHash.getNodeInfo(key).Equals("192.168.0.0-服务器0"))
                {
                    _0++;
                }
                else if (consistencyHash.getNodeInfo(key).Equals("192.168.0.1-服务器1"))
                {
                    _1++;
                }
                else if (consistencyHash.getNodeInfo(key).Equals("192.168.0.2-服务器2"))
                {
                    _2++;
                }
                else if (consistencyHash.getNodeInfo(key).Equals("192.168.0.3-服务器3"))
                {
                    _3++;
                }
                else if (consistencyHash.getNodeInfo(key).Equals("192.168.0.4-服务器4"))
                {
                    _4++;
                }
                else
                {
                    Console.WriteLine("error");
                }
            }

            // 输出每台服务器负载情况
            Console.WriteLine("_0 = " + _0);
            Console.WriteLine("_1 = " + _1);
            Console.WriteLine("_2 = " + _2);
            Console.WriteLine("_3 = " + _3);
            Console.WriteLine("_4 = " + _4);

            Console.Read();

        }

 运行结果