权重轮询调度算法(Weighted Round-Robin 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 =
                         },
                     new Server()
                         {
                             IP = "192.168.0.101",
                             Weight =
                         },
                     new Server()
                         {
                             IP = "192.168.0.102",
                             Weight =
                         },
                     new Server()
                         {
                             IP = "192.168.0.103",
                             Weight =
                         },
                     new Server()
                         {
                             IP = "192.168.0.104",
                             Weight =
                         },
                 }.OrderBy(a => a.Weight).ToList();

         private static int i = -;//代表上一次选择的服务器
         private static int gcd = GetGcd(s);//表示集合S中所有服务器权值的最大公约数
         private static int cw = ;//当前调度的权值
         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 + ) % n;
                 if (i == )
                 {
                     cw = cw - gcd;
                     if (cw <= )
                     {
                         cw = max;
                         if (cw == )
                             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 ;
         }
         /// <summary>
         /// 获取最大的权值
         /// </summary>
         /// <param name="servers"></param>
         /// <returns></returns>
         private static int GetMaxWeight(List<Server> servers)
         {
             int max = ;
             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 = ; j < ; 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, );
                 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