क्या मुझे स्थिर अस्थिर चर को सिंक्रनाइज़ करना चाहिए?

Question

इस विषय पर कुछ प्रश्न हैं, लेकिन इस समस्या के आसपास सबसे अधिक स्कर्ट क्योंकि यह सवाल का इरादा नहीं है।

अगर मैं मेरी कक्षा में एक स्थिर अस्थिर है:

private static volatile MyObj obj = null; 

और एक विधि में नीचे मैं करता हूँ:

public MyObj getMyObj() { 
    if (obj == null) { 
     obj = new MyObj();// costly initialisation 
    } 
    return obj; 
} 

मैं केवल एक धागा क्षेत्र के लिए लिखते हैं सुनिश्चित करने के लिए सिंक्रनाइज़ करना होगा , या obj == null सशर्त मूल्यांकन का मूल्यांकन करने वाले अन्य धागे के लिए तत्काल दिखाई देगा?

इसे एक और तरीका रखने के लिए: क्या अस्थिरता आपको स्थैतिक चर पर लिखने के लिए सिंक्रनाइज़ करने के आसपास मिलती है?

Answer 1

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

व्यक्तिगत तौर पर मैं काफ़ी होगा तीन विकल्पों में से एक:

• प्रारंभ वर्ग लोड पर (जानते हुए भी कि कि आलसी होगा, लेकिन आलसी के रूप में नहीं के रूप में getMyObj जब तक इंतज़ार कर पहले कहा जाता है):

  private static final MyObj obj = new MyObj(); 
  

  बिना शर्त ताला

• उपयोग:

  private static MyObj obj; 
  private static final Object objLock = new Object(); 
  
  public static MyObj getMyObj() { 
      synchronized(objLock) { 
       if (obj == null) { 
        obj = new MyObj(); 
       } 
       return obj; 
      } 
  } 
  

• आलस्य के लिए एक नेस्टेड वर्ग का प्रयोग करें कि जिस तरह से:

  public static MyObj getMyObj() { 
      return MyObjHolder.obj; 
  } 
  
  private static class MyObjHolder { 
      static final MyObj obj = new MyObj(); 
  } 
  

Answer 2

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

इस तरह की घटनाओं की एक अनुक्रम पर विचार करें:

1. थ्रेड एक getMyObj() प्रवेश करती है और देखता है कि obj == null
2. थ्रेड बी में प्रवेश करती है getMyObj() और देखता है कि obj == null
3. थ्रेड एक निर्माण करती है एक new MyObj() - यह objA कॉल
4. थ्रेड बी new MyObj() बनाता है - चलिए इसे objB
पर कॉल करें
5. थ्रेड एक प्रदान करती है objAobj
6. को थ्रेड बी प्रदान करती है objBobj (जो इस बिंदु पर अब और null नहीं है, इसलिए थ्रेड एक द्वारा आवंटित objA के संदर्भ में,, ओवरराइट है)
7. थ्रेड एक बाहर निकालता है getMyObj() और शुरू होता है objA
8. थ्रेड बी का उपयोग करने के getMyObj() बाहर निकालता है और objB

इस परिदृश्य उपयोग करने के लिए शुरू होता है किसी भी धागे के साथ हो सकता है। ध्यान दें कि यद्यपि, सादगी के लिए, मैंने घटनाओं का सख्त क्रम माना, वास्तविक बहुप्रचारित पर्यावरण कार्यक्रमों में 1-2, 3-4 और/या 7-8 आंशिक रूप से या पूरी तरह ओवरलैप कर सकते हैं, बिना अंत को बदल दिए परिणाम।

धारक मुहावरा करने के लिए एक उदाहरण:

public class Something { 
    private Something() { 
    } 

    private static class LazyHolder { 
     public static final Something INSTANCE = new Something(); 
    } 

    public static Something getInstance() { 
     return LazyHolder.INSTANCE; 
    } 
} 

यह गारंटी है, सुरक्षित है के रूप में INSTANCEfinal है। जावा मेमोरी मॉडल गारंटी देता है कि final फ़ील्ड प्रारंभिक कक्षा को लोड करने पर, किसी भी संख्या में धागे को सही ढंग से दिखाई देकर दिखाई दे रहे हैं। चूंकि LazyHolderprivate है और केवल getInstance() द्वारा संदर्भित किया गया है, यह केवल तब लोड हो जाएगा जब getInstance() पहले कॉल किया जाता है। और उस बिंदु पर, INSTANCE पृष्ठभूमि में आरंभ किया गया है और JVM द्वारा सुरक्षित रूप से प्रकाशित किया गया है।

Answer 3

वह कोड धागा सुरक्षित नहीं है। यदि एकाधिक धागे फ़ंक्शन निष्पादित करते हैं तो MyObj के कई उदाहरण बनाए जा सकते हैं। आपको सिंक्रनाइज़ेशन के कुछ रूपों की आवश्यकता है।

मौलिक मुद्दा इस ब्लॉक कोड है जो:

if (obj == null) { 
    obj = new MyObj();// costly initialisation 
} 

परमाणु नहीं है। वास्तव में यह परमाणु होने से बहुत लंबा रास्ता है।

Answer 4

नहीं, आप अभी भी पहुंच सिंक्रनाइज़ करना होगा। volatile अन्य धागे द्वारा एक धागे द्वारा एक चर में किए गए परिवर्तनों की अनुमति देता है।

1. obj initally रिक्त है:

   निष्पादन के निम्न प्रवाह (दो धागे टी 1 & टी 2 कल्पना करते हुए) की कल्पना करें।

2. टी 1: अगर (obj == नल): हाँ
3. टी 2: यह
4. टी 2 obj को MyObj का एक नया उदाहरण बनाता है और आवंटित: अगर (obj == नल): हाँ
5. T1 भी MyObj का एक नया उदाहरण बनाता है और इसे

आप दो बार एक ऑब्जेक्ट बनाते हैं जिसे आप केवल एक बार बनाए जाने की उम्मीद करते हैं। और यह बुरा परिदृश्य नहीं है। आप उस ऑब्जेक्ट को वापस कर सकते हैं जो अब आपके चर के लिए असाइन नहीं किया गया है। (: केवल जावा 5 या नए के साथ, जानकारी के लिए here देखने के काम करता है नोट):

public class DoubleCheckingSingletonExample 
{ 
    private static final Object lockObj = new Object(); 

    private static volatile DoubleCheckingSingletonExample instance; 

    private DoubleCheckingSingletonExample() 
    { 
     //Initialization 
    } 

    public static DoubleCheckingSingletonExample getInstance() 
    { 
     if(instance == null) 
     { 
      synchronized(lockObj) 
      { 
       if(instance == null) 
       { 
        instance = new DoubleCheckingSingletonExample(); 
       } 
      } 
     } 

     return instance; 
    } 
} 

getInstance एक साथ दो धागे से बुलाया जाता है, दोनों पहले होगा

Answer 5

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