सिंक्रोनाइज्ड विधि
सिंक्रोनाइज़्ड तरीकों के दो प्रभाव होते हैं।
सबसे पहले, जब एक धागा किसी ऑब्जेक्ट के लिए एक सिंक्रनाइज़ किए गए तरीके को निष्पादित कर रहा है, तो अन्य सभी थ्रेड्स जो ऑब्जेक्ट के साथ पहला थ्रेड तब तक ब्लॉक किए जाते हैं, जब तक कि एक ही ऑब्जेक्ट ब्लॉक (सस्पेंडेड एक्जीक्यूशन) के लिए सिंक्रनाइज़ किए गए तरीकों को लागू न करें।
दूसरा, जब एक सिंक्रनाइज़ की गई विधि बाहर निकलती है, तो यह स्वचालित रूप से एक ही ऑब्जेक्ट के लिए एक सिंक्रनाइज़ किए गए विधि के किसी भी बाद के आह्वान के साथ एक-पहले संबंध स्थापित करता है। यह गारंटी देता है कि ऑब्जेक्ट की स्थिति में परिवर्तन सभी थ्रेड्स को दिखाई देते हैं।
ध्यान दें कि कंस्ट्रक्टर को सिंक्रनाइज़ नहीं किया जा सकता है - एक कंस्ट्रक्टर के साथ सिंक्रनाइज़ कीवर्ड का उपयोग करना एक सिंटैक्स त्रुटि है। कंस्ट्रक्टर्स को सिंक्रोनाइज़ करने का कोई मतलब नहीं है, क्योंकि जिस थ्रेड से कोई ऑब्जेक्ट बनता है, उसका निर्माण करते समय उसकी पहुंच होनी चाहिए।
सिंक्रोनाइज़्ड स्टेटमेंट
सिंक्रनाइज़ किए गए तरीकों के विपरीत, सिंक्रनाइज़ किए गए कथनों को उस ऑब्जेक्ट को निर्दिष्ट करना होगा जो आंतरिक लॉक प्रदान करता है: अक्सर मैं इसका उपयोग किसी सूची या मानचित्र पर एक्सेस को सिंक्रनाइज़ करने के लिए करता हूं, लेकिन मैं ऑब्जेक्ट के सभी तरीकों तक पहुंच को अवरुद्ध नहीं करना चाहता।
प्रश्न: आंतरिक लॉक और सिंक्रोनाइज़ेशन सिंक्रोनाइज़ेशन आंतरिक इकाई के आसपास बनाया गया है जिसे आंतरिक लॉक या मॉनिटर लॉक के रूप में जाना जाता है। (एपीआई विनिर्देश अक्सर इस इकाई को केवल "मॉनिटर" के रूप में संदर्भित करता है) आंतरिक ताले सिंक्रनाइज़ेशन के दोनों पहलुओं में एक भूमिका निभाते हैं: किसी वस्तु की स्थिति के लिए अनन्य पहुंच को लागू करना और ऐसा होना चाहिए-पहले रिश्ते जो दृश्यता के लिए आवश्यक हैं।
प्रत्येक वस्तु में एक आंतरिक ताला जुड़ा होता है। कन्वेंशन द्वारा, एक थ्रेड जिसे किसी ऑब्जेक्ट के फ़ील्ड में अनन्य और लगातार एक्सेस की आवश्यकता होती है, उन्हें एक्सेस करने से पहले ऑब्जेक्ट के आंतरिक लॉक का अधिग्रहण करना पड़ता है, और फिर आंतरिक लॉक को तब जारी करते हैं जब यह उनके साथ हो जाता है। यह कहा जाता है कि लॉक को प्राप्त करने और लॉक जारी करने के बीच के समय में एक धागे को आंतरिक लॉक कहा जाता है। जब तक एक धागा एक आंतरिक लॉक का मालिक होता है, कोई भी अन्य धागा एक ही लॉक का अधिग्रहण नहीं कर सकता है। जब वह लॉक हासिल करने का प्रयास करेगा तो दूसरा धागा ब्लॉक हो जाएगा।
package test;
public class SynchTest implements Runnable {
private int c = 0;
public static void main(String[] args) {
new SynchTest().test();
}
public void test() {
// Create the object with the run() method
Runnable runnable = new SynchTest();
Runnable runnable2 = new SynchTest();
// Create the thread supplying it with the runnable object
Thread thread = new Thread(runnable,"thread-1");
Thread thread2 = new Thread(runnable,"thread-2");
// Here the key point is passing same object, if you pass runnable2 for thread2,
// then its not applicable for synchronization test and that wont give expected
// output Synchronization method means "it is not possible for two invocations
// of synchronized methods on the same object to interleave"
// Start the thread
thread.start();
thread2.start();
}
public synchronized void increment() {
System.out.println("Begin thread " + Thread.currentThread().getName());
System.out.println(this.hashCode() + "Value of C = " + c);
// If we uncomment this for synchronized block, then the result would be different
// synchronized(this) {
for (int i = 0; i < 9999999; i++) {
c += i;
}
// }
System.out.println("End thread " + Thread.currentThread().getName());
}
// public synchronized void decrement() {
// System.out.println("Decrement " + Thread.currentThread().getName());
// }
public int value() {
return c;
}
@Override
public void run() {
this.increment();
}
}
क्रॉस जांच अलग-अलग आउटपुट को सिंक्रोनाइज़ करने की विधि, ब्लॉक और बिना सिंक्रोनाइज़ेशन के।