जावा राउंड-रॉबिन धागा-सुरक्षित कार्यान्वयन

अच्छा दिन है, प्रिय हैब्रिटाटेल।

एक ठीक कार्य दिवस, अधिकारियों ने हमारे सिस्टम में प्रदर्शन को बेहतर बनाने के लिए कई सर्वरों का उपयोग करने की क्षमता को जोड़ने का कार्य निर्धारित किया। विशेष साधनों के माध्यम से क्लस्टर और संतुलन का विस्तार करना संभव नहीं था। इसलिए, मुझे राउंड-रॉबिन एल्गोरिथ्म का उपयोग करके अपने स्वयं के कार्यान्वयन का आविष्कार करना पड़ा।

एल्गोरिथ्म

एप्लिकेशन के आर्किटेक्चर के आधार पर, यह निर्णय लिया गया कि बैलेंसिंग उन सर्वरों की सूची के माध्यम से किया जाना चाहिए जो कॉन्फ़िगरेशन में निर्दिष्ट हैं और एक नए अनुरोध पर अगले सर्वर का पता जारी कर रहे हैं।



यह सिद्धांत राउंड-रॉबिन एल्गोरिथ्म को रेखांकित करता है।

कार्यान्वयन

इंटरनेट पर खोज करने के बाद, मुझे इस एल्गोरिथ्म को लागू करने के लिए कई विकल्प मिले, जो निम्न कोड के लिए उबला हुआ था:

public synchronized Entity getNext_Iterator(){ if (!it.hasNext()) { it = objectList.iterator(); } return it.next(); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यहाँ ऑब्जेक्टलिस्ट उपलब्ध सर्वरों की एक सूची है।



इस कार्यान्वयन में, मुझे सिंक्रनाइज़ पद्धति का उपयोग पसंद नहीं आया, इसलिए मैंने निम्नलिखित कार्यान्वयन का प्रस्ताव दिया:

1. आरंभीकरण के दौरान, उपलब्ध सर्वरों की एक सूची बनाई जाती है और इस सूची की लंबाई संरक्षित होती है। एक वैश्विक काउंटर एटोमिकइंटरजर डेटा प्रकार और 0 के प्रारंभिक मूल्य के साथ बनाया गया है
2. सर्वर पते का अनुरोध करते समय, काउंटर 1 से बढ़ जाता है। यदि परिणामी मूल्य सूची की लंबाई से अधिक है, तो काउंटर को शून्य करें। हम सूची में एक सूचकांक के रूप में इस काउंटर के मूल्य का उपयोग करते हैं।

अब सीधे परिणामी कोड ( relgames सलाह के लिए धन्यवाद):

  private final AtomicInteger position = new AtomicInteger(0); private volatile int listSize; ... public synchronized void init(List<Entity> objects) { ... listSize = objectList.size(); ... } } public Entity getNext() { return objectList.get(getNextPosition()); } public final int getNextPosition() { for (;;) { int current = position.get(); int next = current + 1; if(next >= listSize){ next = 0; } if (position.compareAndSet(current, next)) return current; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस कार्यान्वयन के प्रदर्शन का परीक्षण करने के लिए, एक छोटा कार्यक्रम लोड के तहत लिखा गया था।

परीक्षण पद्धति में इस तथ्य को समाहित किया गया था कि सर्वर पते को एक अलग संख्या में थ्रेड्स (1 से 991 तक) प्राप्त करने के लिए 1,000,000 अनुरोध किए गए थे और पते को प्राप्त करने के लिए औसत समय मापा गया था।



परिणाम एक ग्राफ में प्रस्तुत किए जाते हैं और यहां देखे जा सकते हैं ।

यहाँ प्रयोगों के लिए स्रोत।

वह डेटा जिस पर रेखांकन आधारित है, यहाँ है ।



आपका ध्यान देने के लिए धन्यवाद।



पुनश्च प्रस्तावित कार्यान्वयन विकल्प एकल-थ्रेडेड सिस्टम में काम करते समय और दोनों बहु-थ्रेडेड सिस्टम में काम करते समय समान रूप से स्थिर काम करता है, जो कि ग्राफ पर स्पष्ट रूप से दिखाई देता है। यह इस कार्यान्वयन का मुख्य लाभ है।



युपीडी:

पुराना शेड्यूल यहां है । अनुसंधान तब एक धीमी कंप्यूटर पर आयोजित किया गया था।