मल्टीथ्रेडेड पैटर्न

3.1 सक्रिय वस्तु

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

सरलीकृत संस्करण:

क्लासिक संस्करण:

इस टेम्पलेट में छह तत्व हैं:

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

3.2 ताला

लॉक पैटर्न एक तुल्यकालन तंत्र है जो कई थ्रेड्स के बीच एक साझा संसाधन तक विशेष पहुंच की अनुमति देता है। समवर्ती नियंत्रण नीति को लागू करने का एक तरीका ताले हैं।

मूल रूप से, एक सॉफ्ट लॉक का उपयोग इस धारणा के साथ किया जाता है कि संबंधित साझा संसाधन तक पहुँचने से पहले प्रत्येक थ्रेड "लॉक प्राप्त करने" का प्रयास करता है।

हालाँकि, कुछ प्रणालियाँ एक अनिवार्य लॉकिंग मैकेनिज्म प्रदान करती हैं जिससे एक लॉक किए गए संसाधन पर अनधिकृत पहुँच का प्रयास उस थ्रेड पर एक अपवाद फेंक कर निरस्त कर दिया जाएगा जिसने पहुँच प्राप्त करने का प्रयास किया था।

एक सेमाफोर सबसे सरल प्रकार का ताला है। डेटा एक्सेस के संदर्भ में, एक्सेस मोड्स के बीच कोई अंतर नहीं किया गया है: साझा (रीड-ओनली) या एक्सक्लूसिव (रीड-राइट)। साझा मोड में, एकाधिक थ्रेड केवल-पढ़ने के लिए मोड में डेटा तक पहुंचने के लिए लॉक का अनुरोध कर सकते हैं। एक्सक्लूसिव एक्सेस मोड का उपयोग एल्गोरिदम को अपडेट करने और हटाने में भी किया जाता है।

धागे के निष्पादन की निरंतरता को अवरुद्ध करने की रणनीति द्वारा ताले के प्रकार को अलग किया जाता है। अधिकांश कार्यान्वयन में, लॉक के लिए अनुरोध थ्रेड को तब तक निष्पादित करने से रोकता है जब तक कि लॉक संसाधन उपलब्ध न हो।

एक स्पिनलॉक एक ताला है जो पहुंच प्रदान किए जाने तक लूप में प्रतीक्षा करता है। यदि कोई थ्रेड थोड़े समय के लिए लॉक की प्रतीक्षा करता है, तो ऐसा लॉक बहुत ही कुशल होता है, इस प्रकार थ्रेड्स के अत्यधिक पुनर्निर्धारण से बचा जाता है। यदि थ्रेड्स में से एक लंबे समय तक लॉक रखता है तो एक्सेस की प्रतीक्षा करने की लागत महत्वपूर्ण होगी।

लॉकिंग तंत्र को प्रभावी ढंग से लागू करने के लिए हार्डवेयर स्तर पर समर्थन की आवश्यकता होती है। हार्डवेयर समर्थन को "टेस्ट-एंड-सेट", "लाने और जोड़ने" या "तुलना-और-स्वैप" जैसे एक या अधिक परमाणु संचालन के रूप में लागू किया जा सकता है। इस तरह के निर्देश आपको बिना किसी रुकावट के जांच करने की अनुमति देते हैं कि लॉक मुक्त है, और यदि ऐसा है, तो लॉक प्राप्त करें।

3.3 मॉनिटर

मॉनिटर पैटर्न एक उच्च-स्तरीय प्रोसेस इंटरेक्शन और सिंक्रोनाइज़ेशन मैकेनिज्म है जो साझा संसाधनों तक पहुँच प्रदान करता है। एक सामान्य संसाधन, आमतौर पर हार्डवेयर या चर के सेट का उपयोग करके दो या अधिक कंप्यूटर कार्यों को सिंक्रनाइज़ करने का एक तरीका।

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

मॉनिटर में निम्न शामिल हैं:

• प्रक्रियाओं का एक सेट जो एक साझा संसाधन के साथ इंटरैक्ट करता है
• म्युटेक्स
• इस संसाधन से जुड़े चर
• एक अपरिवर्तनीय जो दौड़ की स्थिति से बचने के लिए शर्तों को परिभाषित करता है

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

इस प्रकार सिंक्रनाइज़wait() ऑपरेटर जावा में और विधियों के साथ काम करता है notify()।

3.4 डबल चेक लॉकिंग

डबल चेक लॉकिंग एक समानांतर डिज़ाइन पैटर्न है जिसका उद्देश्य लॉक प्राप्त करने के ओवरहेड को कम करना है।

सबसे पहले, बिना किसी सिंक्रोनाइज़ेशन के ब्लॉकिंग स्थिति की जाँच की जाती है। एक थ्रेड लॉक प्राप्त करने का प्रयास केवल तभी करता है जब चेक का परिणाम इंगित करता है कि उसे लॉक प्राप्त करने की आवश्यकता है।

//Double-Checked Locking
public final class Singleton {
private static Singleton instance; //Don't forget volatile modifier

public static Singleton getInstance() {
     if (instance == null) {                //Read

         synchronized (Singleton.class) {    //
             if (instance == null) {         //Read Write
                 instance = new Singleton(); //
             }
         }
     }
 }

थ्रेड-सुरक्षित वातावरण में सिंगलटन ऑब्जेक्ट कैसे बनाएं?

public static Singleton getInstance() {
   if (instance == null)
    instance = new Singleton();
}

यदि आप अलग-अलग थ्रेड्स से सिंगलटन ऑब्जेक्ट बनाते हैं, तो ऐसी स्थिति हो सकती है जहां एक ही समय में कई ऑब्जेक्ट बनाए जाते हैं, और यह अस्वीकार्य है। इसलिए, वस्तु निर्माण को एक सिंक्रनाइज़ स्टेटमेंट में लपेटना उचित है।

public static Singleton getInstance() {
    synchronized (Singleton.class) {
        if (instance == null)
        instance = new Singleton();
    }
}

यह दृष्टिकोण काम करेगा, लेकिन इसका एक छोटा नकारात्मक पहलू है। ऑब्जेक्ट बनने के बाद, हर बार जब आप इसे भविष्य में प्राप्त करने का प्रयास करते हैं, तो सिंक्रोनाइज़्ड ब्लॉक में एक चेक किया जाएगा, जिसका अर्थ है कि वर्तमान थ्रेड और इससे जुड़ी हर चीज़ लॉक हो जाएगी। तो इस कोड को थोड़ा अनुकूलित किया जा सकता है:

public static Singleton getInstance() {
     if (instance != null)
        return instance;

    synchronized (Singleton.class) {
        if (instance == null)
        instance = new Singleton();
    }
}

कुछ भाषाओं और/या कुछ मशीनों पर इस पैटर्न को सुरक्षित रूप से लागू करना संभव नहीं है। इसलिए, इसे कभी-कभी एंटी-पैटर्न कहा जाता है। इस तरह की विशेषताओं ने जावा मेमोरी मॉडल और सी ++ मेमोरी मॉडल में "पहले होता है" सख्त आदेश संबंध की उपस्थिति को जन्म दिया है।

यह आम तौर पर सिंगलटन डिजाइन पैटर्न जैसे बहु-थ्रेडेड प्रोग्रामों में आलसी प्रारंभिकरण को लागू करने के ऊपरी हिस्से को कम करने के लिए प्रयोग किया जाता है। एक चर के आलसी आरंभीकरण में, आरंभीकरण को तब तक के लिए टाल दिया जाता है जब तक कि गणना में चर के मूल्य की आवश्यकता न हो।

3.5 अनुसूचक

शेड्यूलर एक समानांतर डिज़ाइन पैटर्न है जो शेड्यूलिंग नीति को लागू करने के लिए एक तंत्र प्रदान करता है, लेकिन किसी विशेष नीति से स्वतंत्र होता है। उस क्रम को नियंत्रित करता है जिसमें थ्रेड्स को अनुक्रमिक कोड निष्पादित करना चाहिए, एक ऑब्जेक्ट का उपयोग करके जो प्रतीक्षा थ्रेड्स के अनुक्रम को स्पष्ट रूप से निर्दिष्ट करता है।