सिंक्रनाइज़ कथन के साथ पुनर्वित्त सिंक्रनाइज़ेशन व्यवहार

Question

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

public class Someclass 
{ 
    private static final Object LCK_OBJ = new Object(); 
    //..... 

    publc void method1() 
    { 
    //some code.... 
    synchronized(LCK_OBJ) 
    { 
     //some sychronized code. 
     method2(..); 
    } 
    //some more code.... 
    } 

    protected static final void method2(..) 
    { 
     Someclass ref = null; 
     //some code which gets different other references of SomeClass in a loop.... 
     ref.method3(..); 
    } 

    publc void method3() 
    { 
    //some code.... 
    synchronized(LCK_OBJ) 
    { 
     //some sychronized code. 
    } 
    //some more code.... 
    } 

}//end of class  

Answer 1

हाँ आप कर सकते हैं, लेकिन यह कोड संकलित नहीं होगा: आप एक स्थिर विधि "विधि 2" से एक विधि विधि "method3" को बुला रहे हैं। इसके अलावा: यदि कोई थ्रेड "method1" में लॉक प्राप्त करने में कामयाब रहा है, तो अभी भी "method3" में लॉक होगा।

Answer 2

हाँ, एक ही धागे में एक ही ताला पर कई बार एक synchronized ब्लॉक डाल सकते हैं। सावधान रहें कि किसी अन्य क्रम में अन्य ताले हासिल न करें, अन्यथा आप डेडलॉक का कारण बन सकते हैं।

Answer 3

हां, सिंक्रनाइज़ किए गए ब्लॉक पुनर्वित्तक हैं। ReentrantLock भी पुनर्वित्तक है और यदि आप स्वयं ब्लॉक को कोड करना चाहते हैं, तो आप इसके बजाय इसका उपयोग करना चाहेंगे क्योंकि इसमें अधिक flexibiliy/कार्यक्षमता है।

मुझे यकीन है कि किसी भी ताला final एक ताला वस्तु अंतिम नहीं हो सकता तो है बनाना होगा, यह लगभग निश्चित रूप से एक बग (या भ्रम का एक स्रोत)

तुलना प्रयोजनों के लिए है, न कि जावा में सभी ताले रैत्रांत हैं। फ़ाइल लॉक ऐसा नहीं है क्योंकि यह सीधे ओएस को अनुरोध पास करता है।

Answer 4

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