मल्टीथ्रेडेड नमुने

3.1 सक्रिय ऑब्जेक्ट

अ‍ॅक्टिव्ह ऑब्जेक्ट हा एक डिझाईन पॅटर्न आहे जो मेथडचा एक्झिक्युशन थ्रेड ज्या थ्रेडमध्ये कॉल केला होता त्यापासून वेगळे करतो. या पॅटर्नचा उद्देश असिंक्रोनस मेथड कॉल आणि विनंती प्रोसेसिंग शेड्यूलर वापरून समांतर अंमलबजावणी प्रदान करणे आहे.

सरलीकृत आवृत्ती:

क्लासिक प्रकार:

या टेम्पलेटमध्ये सहा घटक आहेत:

• एक प्रॉक्सी ऑब्जेक्ट जी क्लायंटच्या सार्वजनिक पद्धतींना इंटरफेस प्रदान करते.
• एक इंटरफेस जो सक्रिय ऑब्जेक्टसाठी प्रवेश पद्धती परिभाषित करतो.
• क्लायंटकडून येणाऱ्या विनंत्यांची यादी.
• एक शेड्युलर जो क्वेरी कोणत्या क्रमाने अंमलात आणायचा हे ठरवतो.
• सक्रिय ऑब्जेक्ट पद्धतींची अंमलबजावणी.
• क्लायंटला परिणाम प्राप्त करण्यासाठी कॉलबॅक प्रक्रिया किंवा व्हेरिएबल.

3.2 लॉक

लॉक पॅटर्न ही एक सिंक्रोनाइझेशन यंत्रणा आहे जी एकाधिक थ्रेड्स दरम्यान सामायिक केलेल्या स्त्रोतामध्ये अनन्य प्रवेशास अनुमती देते. समवर्ती नियंत्रण धोरण लागू करण्याचा लॉक हा एक मार्ग आहे.

मूलतः, प्रत्येक थ्रेड संबंधित सामायिक संसाधनात प्रवेश करण्यापूर्वी "लॉक मिळवण्याचा" प्रयत्न करतो या गृहीतासह, एक सॉफ्ट लॉक वापरला जातो.

तथापि, काही सिस्टीम एक अनिवार्य लॉकिंग यंत्रणा प्रदान करतात ज्याद्वारे लॉक केलेल्या संसाधनावर अनधिकृत प्रवेश करण्याचा प्रयत्न थ्रेडवर अपवाद टाकून रद्द केला जाईल ज्याने प्रवेश मिळविण्याचा प्रयत्न केला.

सेमाफोर हा लॉकचा सर्वात सोपा प्रकार आहे. डेटा ऍक्सेसच्या संदर्भात, ऍक्सेस मोडमध्ये कोणताही फरक केला जात नाही: सामायिक (केवळ-वाचनीय) किंवा अनन्य (वाचन-लेखन). शेअर्ड मोडमध्ये, एकाधिक थ्रेड केवळ-वाचनीय मोडमध्ये डेटा ऍक्सेस करण्यासाठी लॉकची विनंती करू शकतात. अद्ययावत आणि हटवा अल्गोरिदममध्ये देखील विशेष प्रवेश मोड वापरला जातो.

थ्रेडच्या अंमलबजावणीची निरंतरता अवरोधित करण्याच्या धोरणाद्वारे लॉकचे प्रकार वेगळे केले जातात. बहुतेक अंमलबजावणीमध्ये, लॉकसाठी विनंती थ्रेडला लॉक केलेले संसाधन उपलब्ध होईपर्यंत कार्यान्वित होण्यापासून प्रतिबंधित करते.

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

लॉकिंग यंत्रणा प्रभावीपणे अंमलात आणण्यासाठी, हार्डवेअर स्तरावर समर्थन आवश्यक आहे. हार्डवेअर समर्थन एक किंवा अधिक अणू ऑपरेशन्स जसे की "चाचणी-आणि-सेट", "फेच-आणि-जोडा" किंवा "तुलना-आणि-स्वॅप" म्हणून लागू केले जाऊ शकते. अशा सूचनांमुळे तुम्हाला लॉक मोकळे आहे की नाही हे तपासण्याची परवानगी मिळते आणि तसे असल्यास लॉक मिळवा.

3.3 मॉनिटर

मॉनिटर पॅटर्न ही उच्च-स्तरीय प्रक्रिया परस्परसंवाद आणि सिंक्रोनाइझेशन यंत्रणा आहे जी सामायिक संसाधनांमध्ये प्रवेश प्रदान करते. सामान्य संसाधन, सामान्यतः हार्डवेअर किंवा व्हेरिएबल्सचा संच वापरून दोन किंवा अधिक संगणक कार्ये समक्रमित करण्याचा दृष्टीकोन.

मॉनिटर-आधारित मल्टीटास्किंगमध्ये, कंपाइलर किंवा इंटरप्रिटर पारदर्शकपणे प्रोग्रामरला योग्य स्वरूपित रूटीनमध्ये लॉक-अनलॉक कोड घालतो, प्रोग्रामरला स्पष्टपणे सिंक्रोनाइझेशन प्रिमिटिव्ह कॉल करण्यापासून वाचवतो.

मॉनिटरमध्ये हे समाविष्ट आहे:

• कार्यपद्धतींचा संच जो सामायिक संसाधनाशी संवाद साधतो
• mutex
• या संसाधनाशी संबंधित चल
• एक अपरिवर्तनीय जो शर्यतीची स्थिती टाळण्यासाठी परिस्थिती परिभाषित करतो

मॉनिटर प्रक्रिया काम सुरू करण्यापूर्वी म्युटेक्स मिळवते आणि प्रक्रिया बाहेर येईपर्यंत किंवा विशिष्ट स्थितीची प्रतीक्षा होईपर्यंत ते धरून ठेवते. जर प्रत्येक प्रक्रिया म्युटेक्स सोडण्यापूर्वी अपरिवर्तनीय सत्य असल्याची हमी देत ​​असेल, तर कोणतेही कार्य शर्यतीच्या स्थितीत संसाधन मिळवू शकत नाही.

अशा प्रकारे सिंक्रोनाइझ केलेलाwait() ऑपरेटर Java मध्ये आणि पद्धतींसह कार्य करतो 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();
    }
}

काही भाषांवर आणि/किंवा काही मशीनवर हा पॅटर्न सुरक्षितपणे अंमलात आणणे शक्य नाही. म्हणून, त्याला कधीकधी अँटी-पॅटर्न म्हटले जाते. अशा वैशिष्ट्यांमुळे जावा मेमरी मॉडेल आणि C++ मेमरी मॉडेलमध्ये "हॅपेन्स अगोदर" कडक ऑर्डर रिलेशनशिप दिसू लागली आहे.

हे विशेषत: सिंगलटन डिझाइन पॅटर्न सारख्या मल्टी-थ्रेडेड प्रोग्राम्समध्ये आळशी आरंभीकरण लागू करण्याचे ओव्हरहेड कमी करण्यासाठी वापरले जाते. व्हेरिएबलच्या आळशी प्रारंभामध्ये, गणनेमध्ये व्हेरिएबलचे मूल्य आवश्यक होईपर्यंत आरंभीकरण पुढे ढकलले जाते.

3.5 शेड्युलर

शेड्यूलर हा एक समांतर डिझाइन पॅटर्न आहे जो शेड्यूलिंग धोरणाची अंमलबजावणी करण्यासाठी एक यंत्रणा प्रदान करतो, परंतु कोणत्याही विशिष्ट धोरणापासून स्वतंत्र असतो. वेटिंग थ्रेड्सचा क्रम स्पष्टपणे निर्दिष्ट करणार्‍या ऑब्जेक्टचा वापर करून, थ्रेड्सने अनुक्रमिक कोड कार्यान्वित करावा या क्रमाने नियंत्रित करते.