सिंक्रोनाइजर्स: जावा में संसाधनों तक पहुंच को सिंक्रनाइज़ करना

सिकंदरा

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

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

आपको अपने कंप्यूटर या लैपटॉप की शक्ति के आधार पर इस पैरामीटर को व्यक्तिगत रूप से चुनना होगा।

public class Main {

   public static void main(String[] args) {
       Semaphore sem = new Semaphore(1);
       CommonResource res = new CommonResource();
       new Thread(new MyThread(res, sem, "MyThread_1")).start();
       new Thread(new MyThread(res, sem, "MyThread_2")).start();
       new Thread(new MyThread(res, sem, "MyThread_3")).start();
   }
}

class CommonResource {
   int value = 0;
}

class MyThread implements Runnable {
   CommonResource commonResource;
   Semaphore semaphore;
   String name;
   MyThread(CommonResource commonResource, Semaphore sem, String name) {
       this.commonResource = commonResource;
       this.semaphore = sem;
       this.name = name;
   }

   public void run() {

       try {
           System.out.println(name + "waiting permission");
           semaphore.acquire();
           commonResource.value = 1;
           for (int i = 1; i < 7; i++) {
               System.out.println(this.name + ": " + commonResource.value);
               commonResource.value++;
               Thread.sleep(150);
           }
       } catch (InterruptedException e) {
           System.out.println(e.getMessage() + " " + name);
           Thread.currentThread().interrupt();
       }
       System.out.println(name + "releases permission");
       semaphore.release();
   }
}

काउंटडाउन लैच और अन्य

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

जैसे ही गिनती शून्य पर जाती है, प्रतीक्षा में सभी प्रतीक्षा सूत्र अपना काम जारी रखेंगे, और प्रतीक्षा के बाद के सभी कॉल बिना प्रतीक्षा के गुजर जाएंगे। उलटी गिनती काउंटर एक बार का काउंटर है और इसे रीसेट नहीं किया जा सकता है।

साइक्लिक बैरियर - एक बिंदु पर दिए गए थ्रेड्स की संख्या को सिंक्रनाइज़ करने के लिए उपयोग किया जाता है। बाधा तब पहुँचती है जब N थ्रेड्स प्रतीक्षा (...) विधि और ब्लॉक को कॉल करते हैं। उसके बाद, काउंटर को उसके मूल मान पर रीसेट कर दिया जाता है, और प्रतीक्षारत थ्रेड जारी कर दिए जाते हैं। इसके अतिरिक्त, यदि आवश्यक हो, तो थ्रेड्स को अनब्लॉक करने और काउंटर को रीसेट करने से पहले कस्टम कोड चलाना संभव है। ऐसा करने के लिए, रननेबल इंटरफ़ेस के कार्यान्वयन के साथ एक वस्तु को कंस्ट्रक्टर के माध्यम से पारित किया जाता है ।

एक्सचेंजर <वी> - एक्सचेंजर क्लास थ्रेड्स के बीच डेटा एक्सचेंज के लिए अभिप्रेत है। यह टाइप किया जाता है और उस प्रकार के डेटा को टाइप करता है जिसे थ्रेड्स को एक्सचेंज करने की आवश्यकता होती है।

इस वर्ग की एकमात्र विनिमय () पद्धति का उपयोग करके डेटा का आदान-प्रदान किया जाता है :

V exchange(V x) throws InterruptedException
V exchange(V x, long timeout, TimeUnit unit) throws InterruptedException, TimeoutException

एक्स पैरामीटर एक्सचेंज किए जाने वाले डेटा बफर का प्रतिनिधित्व करता है। विधि का दूसरा रूप टाइमआउट पैरामीटर , टाइमआउट और यूनिट को भी परिभाषित करता है, टाइमआउट पैरामीटर के लिए उपयोग की जाने वाली समय इकाई का प्रकार ।

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

फेजर क्लास के साथ काम करते समय , सबसे पहले इसका ऑब्जेक्ट बनाना आम बात है। अगला, हमें सभी प्रतिभागियों को पंजीकृत करने की आवश्यकता है। प्रत्येक प्रतिभागी के लिए पंजीकरण करने के लिए, रजिस्टर () विधि को कहा जाता है, या आप इस विधि के बिना फेजर कंस्ट्रक्टर को प्रतिभागियों की आवश्यक संख्या पास करके कर सकते हैं ।

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