¿Carga de programación con un algoritmo round robin?

Question

Necesito escribir un algoritmo round robin para programar la carga en n puntos finales?

lo que si tengo los servidores A, B y C

que quería asegurarse de que todos contra todos a través de ellos para cada solicitud que consigo. ¿Cómo hago esto en C#?

Answer 1

Sólo para que conste, definición de round robin:

http://en.wikipedia.org/wiki/Round-robin_scheduling

sólo tiene que utilizar una cola. Saca uno de la parte superior, úsalo y vuelve a colocarlo. Esto asegura que el más reciente utilizado siempre será el último en ser recogido.

Queue<Server> q = new Queue<Server>(); 

//get the next one up 
Server s = q.DeQueue(); 


//Use s; 


//put s back for later use. 
q.Enqueue(s); 

Enlace a la clase de cola:

http://msdn.microsoft.com/en-us/library/7977ey2c.aspx

Answer 2

Si se accede a los puntos finales a través de una lista o matriz, sólo es necesario para incrementar el índice de forma circular:

public class RoundRobinIndex 
{ 
    volatile int index = 0; 
    int count; 

    public int Next 
    { 
     get 
     { 
      if (index == count) 
      { 
       index = 0; 
      } 
      return index++; 
     } 
    } 

    public RoundRobinIndex(int countArg) 
    { 
     count = countArg; 
    } 
} 

Answer 3

La misma idea que ebpower, pero se centra en lo que es el siguiente elemento en lugar de lo que es el índice del siguiente elemento.

public class RoundRobinList<T> 
{ 
    private readonly IList<T> _list; 
    private readonly int _size; 
    private int _position; 

    public RoundRobinList(IList<T> list) 
    { 
     if (!list.Any()) 
      throw new NullReferenceException("list"); 

     _list = new List<T>(list); 
     _size = _list.Count;    
    } 

    public T Next() 
    { 
     if (_size == 1) 
      return _list[0]; 

     Interlocked.Increment(ref _position); 
     var mod = _position % _size; 
     return _list[mod]; 
    } 
}