सिंक्रोनायझर्स: जावामधील संसाधनांमध्ये प्रवेश सिंक्रोनाइझ करणे

सेमाफोर

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

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

आपल्या संगणकाच्या किंवा लॅपटॉपच्या सामर्थ्यावर अवलंबून, आपल्याला हे पॅरामीटर वैयक्तिकरित्या निवडण्याची आवश्यकता आहे.

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

CountDownLatch आणि इतर

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

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

CyclicBarrier - एका बिंदूवर दिलेल्या थ्रेड्सची संख्या सिंक्रोनाइझ करण्यासाठी वापरली जाते. जेव्हा N थ्रेड्स await(...) पद्धतीला कॉल करतात आणि ब्लॉक करतात तेव्हा अडथळा गाठला जातो. त्यानंतर, काउंटर त्याच्या मूळ मूल्यावर रीसेट केले जाईल, आणि प्रतीक्षा थ्रेड सोडले जातील. याव्यतिरिक्त, आवश्यक असल्यास, थ्रेड्स अनब्लॉक करण्यापूर्वी आणि काउंटर रीसेट करण्यापूर्वी सानुकूल कोड चालवणे शक्य आहे. हे करण्यासाठी, रन करण्यायोग्य इंटरफेसच्या अंमलबजावणीसह एक ऑब्जेक्ट.

एक्सचेंजर<V> ​​— एक्सचेंजर क्लास थ्रेड्समधील डेटा एक्सचेंजसाठी आहे. हे टाइप केले जाते आणि थ्रेड्सना ज्या डेटाची देवाणघेवाण करणे आवश्यक असते ते टाइप केले जाते.

या वर्गाची एकमेव एक्सचेंज() पद्धत वापरून डेटाची देवाणघेवाण केली जाते :

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

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

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

Phaser वर्गासह काम करताना , प्रथम त्याचे ऑब्जेक्ट तयार करणे सामान्य आहे. पुढे, आम्हाला सर्व सहभागींची नोंदणी करणे आवश्यक आहे. प्रत्येक सहभागीची नोंदणी करण्यासाठी, register() पद्धतीला म्हणतात, किंवा तुम्ही Phaser constructor ला आवश्यक सहभागींची संख्या देऊन या पद्धतीशिवाय करू शकता .

मग प्रत्येक सहभागी क्रियांचा एक विशिष्ट संच करतो ज्यामुळे टप्पा बनतो. आणि फेसर सिंक्रोनायझर सर्व सहभागींनी फेजची अंमलबजावणी पूर्ण करेपर्यंत प्रतीक्षा करतो. सिंक्रोनाइझरला टप्पा संपल्याची माहिती देण्यासाठी, सहभागीने आगमन() किंवा welcomeAndAwaitAdvance() पद्धतीला कॉल करणे आवश्यक आहे . सिंक्रोनायझर नंतर पुढच्या टप्प्यावर जातो.