Planification du chargement avec un algorithme Round Robin?

Question

J'ai besoin d'écrire un algorithme round robin pour planifier la charge à n points de terminaison?

Donc, si j'ai serveurs A, B et C

Je voulais vous assurer de la ronde à travers eux pour chaque demande que je reçois. Comment est-ce que je fais cela en C#?

Answer 1

Pour la petite histoire, la définition du tournoi à la ronde:

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

Il suffit d'utiliser une file d'attente. Enlevez-en une, utilisez-la et remettez-la. Cela garantit que le dernier utilisé sera toujours le dernier à être ramassé.

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); 

Lien vers la classe de file d'attente:

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

Answer 2

Si vos points de terminaison sont accessibles via une liste ou un tableau, il vous suffit d'incrémenter un indice de manière circulaire:

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

Même idée que ebpower, mais en mettant l'accent sur ce qui est l'élément suivant plutôt que sur l'indice de l'élément suivant.

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]; 
    } 
}