सिंक्रनाइज़ ब्लॉक में स्थिर बनाम गैर स्थैतिक लॉक ऑब्जेक्ट

Question

सिंक्रनाइज़ेशन को देखने और समझने की कोशिश कर रहा है।

1. एक स्थिर ताला वस्तु (कोड ए) और एक गैर स्थिर ताला वस्तु (कोड बी) का उपयोग कर के बीच मतभेद एक के लिए सिंक्रनाइज़ ब्लॉक क्या हैं?
2. व्यावहारिक अनुप्रयोगों में यह अलग कैसे है?
3. किसी के पास क्या नुकसान होगा जो दूसरे नहीं होगा?
4. कौन सा उपयोग करने के लिए निर्धारित करने के लिए मानदंड क्या हैं?

कोड एक

public class MyClass1 { 
    private static final Object lock = new Object(); 
    public MyClass1() { 
    //unsync 
    synchronized(lock) { 
     //sync 
    } 
    //unsync 
    } 
} 

कोड बी

public class MyClass2 { 
    private final Object lock = new Object(); 
    public MyClass2() { 
    //unsync 
    synchronized(lock) { 
     //sync 
    } 
    //unsync 
    } 
} 

नोट

ऊपर कोड कंस्ट्रक्टर्स से पता चलता है, लेकिन आप के बारे में कैसे बात कर सकते हैं beha vior एक स्थिर विधि और एक गैर स्थैतिक विधि में भी अलग है। साथ ही, क्या एक स्थिर लॉक का उपयोग करना फायदेमंद होगा जब सिंक्रनाइज़ ब्लॉक स्थिर सदस्य चर को संशोधित कर रहा है?

मैंने पहले ही this question में उत्तर देखा है, लेकिन यह स्पष्ट नहीं है कि विभिन्न उपयोग परिदृश्य क्या हैं।

Answer 1

अंतर सरल है: अगर बंद कर दिया-ऑन वस्तु एक static क्षेत्र में है, तो वह ताला के MyClass*होगा शेयर सभी उदाहरणों (यानी कोई दो वस्तुओं एक ही समय में उस वस्तु पर लॉक करने के लिए सक्षम हो जाएगा) ।

यदि फ़ील्ड गैर-स्थैतिक है, तो प्रत्येक इंस्टेंस का अपना लॉक होगा, इसलिए उसी ऑब्जेक्ट पर विधि को केवल एक दूसरे को लॉक कर देगा।

आप एक स्थिर ताला वस्तु का उपयोग करते हैं:

• धागा 1 कॉल o1.foo()
• धागा 2 कॉल o1.foo(),,
• 3 कॉल o2.foo() खत्म करने के लिए धागा धागा 1 के लिए प्रतीक्षा करनी होगी भी होगा को

को समाप्त करने के लिए थ्रेड 1 (और शायद 2) के लिए प्रतीक्षा करना होगा कहां एक गैर स्थिर ताला वस्तु का उपयोग करें:

• धागा 1 कॉल o1.foo()
• धागा 2 कॉल o1.foo(),
• धागा 3 कॉल o2.foo() खत्म करने के लिए धागा 1 के लिए प्रतीक्षा करनी होगी, यह सिर्फ, जारी रख सकते हैं नहीं धागा 1 और 2

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

अंगूठे के नियम के रूप में, आप लॉक-ऑब्जेक्ट को ऑपरेटेड-ऑन मान की तुलना में static -ness रखना चाहते हैं। तो यदि आप गैर-स्थिर मान केवल में हेरफेर करते हैं, तो आप एक गैर स्थैतिक लॉक ऑब्जेक्ट चाहते हैं। यदि आप स्थिर मान केवल में हेरफेर करते हैं, तो आप एक स्थिर लॉक ऑब्जेक्ट चाहते हैं।

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

अपने विशेष मामले में आप कन्स्ट्रक्टर में लॉक का उपयोग करते हैं, जिसे केवल प्रति उदाहरण एक बार निष्पादित किया जाएगा, इसलिए एक गैर स्थैतिक लॉक-ऑब्जेक्ट यहां कोई समझ नहीं लेता है।