权重轮询调度算法(Weighted RoundRobin Scheduling)C#实现

在多台机器实现负载均衡的时候,存在调度分配的问题.

如果服务器的配置的处理能力都一致的话,平均轮询分配可以直接解决问题,然而有些时候机器的处理能力是不一致的.

假如有2台机器 A和B , A的处理能力是B的2倍,则A的权重为2,B的权重为1.权值高的服务器先收到的连接，权值高的服 务器比权值低的服务器处理更多的连接，相同权值的服务器处理相同数目的连接数。

算法的C#版如下:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
namespace TestConsoleApplication
{
    /// <summary>
    /// 权重轮询算法
    /// </summary>
    public static class WeightedRoundRobin
    {

        private static List<Server> s = new List<Server>()
                {
                    new Server()
                        {
                            IP = "192.168.0.100",
                            Weight = 3
                        },
                    new Server()
                        {
                            IP = "192.168.0.101",
                            Weight = 2
                        },
                    new Server()
                        {
                            IP = "192.168.0.102",
                            Weight = 6
                        },
                    new Server()
                        {
                            IP = "192.168.0.103",
                            Weight = 4
                        },
                    new Server()
                        {
                            IP = "192.168.0.104",
                            Weight = 1
                        },
                }.OrderBy(a => a.Weight).ToList();

        private static int i = -1;//代表上一次选择的服务器
        private static int gcd = GetGcd(s);//表示集合S中所有服务器权值的最大公约数
        private static int cw = 0;//当前调度的权值
        private static int max = GetMaxWeight(s);
        private static int n = s.Count;//服务器个数


        /**
         * 算法流程：
         * 假设有一组服务器 S = {S0, S1, …, Sn-1} ，有相应的权重，变量I表示上次选择的服务器，1每次步长
         * 权值cw初始化为0，i初始化为-1 ，当第一次的时候 权值取最大的那个服务器，
         * 通过权重的不断递减 寻找 适合的服务器返回，直到轮询结束，权值返回为0 
         */
        public static Server GetServer()
        {
            while (true)
            {
                i = (i + 1) % n;
                if (i == 0)
                {
                    cw = cw - gcd;
                    if (cw <= 0)
                    {
                        cw = max;
                        if (cw == 0)
                            return null;
                    }
                }
                if (s[i].Weight >= cw)
                {
                    return s[i];
                }
            }
        }


        /// <summary>
        /// 获取服务器所有权值的最大公约数
        /// </summary>
        /// <param name="servers"></param>
        /// <returns></returns>
        private static int GetGcd(List<Server> servers)
        {
            return 1;
        }
        /// <summary>
        /// 获取最大的权值
        /// </summary>
        /// <param name="servers"></param>
        /// <returns></returns>
        private static int GetMaxWeight(List<Server> servers)
        {
            int max = 0;
            foreach (var s in servers)
            {
                if (s.Weight > max)
                    max = s.Weight;
            }
            return max;
        }
    }
    /// <summary>
    /// 服务器结构
    /// </summary>
    public class Server
    {
        public string IP;
        public int Weight;
    }


    class Program
    {
        static void Main(string[] args)
        {
　　　　　　　Dictionary<string, int> dic = new Dictionary<string, int>();
            Server s;
            for (int j = 0; j < 100; j++)
            {
                s = WeightedRoundRobin.GetServer();
                Console.WriteLine("{0},weight:{1}", s.IP, s.Weight);

                if (!dic.Keys.Contains("服务器" + s.IP + ",权重:" + s.Weight)) 
                    dic.Add("服务器" + s.IP + ",权重:" + s.Weight, 0);
                dic["服务器" + s.IP + ",权重:" + s.Weight]++;
            }

            foreach (var i1 in dic)
            {
                Console.WriteLine("{0}共处理请求{1}次", i1.Key, i1.Value);
            }

            Console.ReadLine();
        }
}

运行结果:

运行100次的结果统计:

参考:http://en.wikipedia.org/wiki/Weighted_round_robin