एक राउंड रॉबिन एल्गोरिदम के साथ लोड शेड्यूलिंग?

Question

मुझे एन एंडपॉइंट्स को लोड शेड्यूल करने के लिए राउंड रॉबिन एल्गोरिदम लिखना होगा?

तो सर्वर ए, बी और सी

मैं प्रत्येक अनुरोध मैं के लिए उन के माध्यम से राउंड-रोबिन को सुनिश्चित करना चाहते थे कि अगर मैं कर दिया है। मैं इसे सी # में कैसे करूं?

Answer 1

बस रिकॉर्ड, राउंड रोबिन की परिभाषा के लिए

:

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

बस एक कतार का उपयोग करें। शीर्ष पर से एक को ले जाएं, इसका इस्तेमाल करें और इसे वापस रखें। यह सुनिश्चित करता है कि सबसे हालिया इस्तेमाल किया जाने वाला हमेशा अंतिम व्यक्ति होगा।

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

कतार वर्ग के लिए लिंक:

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

Answer 2

अपने समाप्ति-बिंदु में सूची या सरणी के माध्यम से पहुँचा रहे हैं, तो आप केवल एक परिपत्र फैशन में एक सूचकांक बढ़ाने के लिए की जरूरत है:

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

ईबॉवर के समान विचार, लेकिन अगले आइटम की अनुक्रमणिका के बजाय अगला आइटम क्या है पर ध्यान केंद्रित करना।

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