जावा में स्थानीय चर थ्रेड सुरक्षित क्यों हैं

Question 1

मैं जावा में मल्टी-थ्रेडिंग पढ़ रहा था और मैं इस पर आता हूं

स्थानीय चर जावा में सुरक्षित हैं।

तब से मैं सोच रहा हूं कि स्थानीय चर कैसे / क्यों सुरक्षित हैं।

क्या कोई मुझे बता सकता है।

Question 2

जब आप एक धागा बनाते हैं तो इसका अपना एक स्टैक बनाया जाएगा। दो थ्रेड्स में दो स्टैक होंगे और एक थ्रेड कभी भी अपने स्टैक को अन्य थ्रेड के साथ साझा नहीं करेगा।

आपके कार्यक्रम में परिभाषित सभी स्थानीय चर को स्टैक में मेमोरी आवंटित की जाएगी (जैसा कि जतिन ने टिप्पणी की है, यहां स्मृति का अर्थ है, वस्तुओं के लिए संदर्भ-मूल्य और आदिम प्रकारों के लिए मूल्य) (प्रत्येक थ्रेड द्वारा कॉल विधि अपने स्टैक पर एक स्टैक फ्रेम बनाती है)। जैसे ही इस थ्रेड द्वारा विधि निष्पादन पूरा हो जाता है, स्टैक फ्रेम हटा दिया जाएगा।

स्टैनफोर्ड प्रोफेसर द्वारा यूट्यूब में बहुत अच्छा व्याख्यान है जो इस अवधारणा को समझने में आपकी मदद कर सकता है।

Question 3

स्थानीय चर प्रत्येक थ्रेड के अपने स्टैक में संग्रहीत होते हैं। इसका मतलब है कि थ्रेड्स के बीच स्थानीय चर कभी साझा नहीं किए जाते हैं। इसका मतलब यह भी है कि सभी स्थानीय आदिम चर धागे सुरक्षित हैं।

public void someMethod(){

   long threadSafeInt = 0;

   threadSafeInt++;
}

वस्तुओं के स्थानीय संदर्भ कुछ अलग हैं। संदर्भ स्वयं साझा नहीं किया गया है। हालाँकि संदर्भित ऑब्जेक्ट, प्रत्येक थ्रेड के स्थानीय स्टैक में संग्रहीत नहीं है। सभी वस्तुओं को साझा किए गए ढेर में संग्रहीत किया जाता है। यदि कोई ऑब्जेक्ट स्थानीय रूप से बनाया गया है, तो वह उस विधि से नहीं बचता है जिसे उसने बनाया था, यह थ्रेड सुरक्षित है। वास्तव में आप इसे अन्य तरीकों और वस्तुओं पर भी पारित कर सकते हैं जब तक कि इनमें से कोई भी विधि या वस्तु पारित वस्तु को अन्य थ्रेड्स के लिए उपलब्ध नहीं कराती है।

Question 4

कार्यक्षमता की परिभाषा जैसी विधियों के बारे में सोचें। जब दो धागे एक ही विधि को चलाते हैं, तो वे किसी भी तरह से संबंधित नहीं होते हैं। वे प्रत्येक प्रत्येक स्थानीय चर का अपना संस्करण बनाएंगे, और किसी भी तरह से एक दूसरे के साथ बातचीत करने में असमर्थ होंगे।

यदि चर स्थानीय नहीं हैं (उदाहरण के लिए वर्ग स्तर पर विधि के बाहर परिभाषित चर), तो वे उदाहरण से जुड़े होते हैं (विधि के एक भी रन के लिए नहीं)। इस स्थिति में, एक ही विधि को चलाने वाले दो धागे एक चर को देखते हैं, और यह थ्रेड-सुरक्षित नहीं है।

इन दो मामलों पर विचार करें:

public class NotThreadsafe {
    int x = 0;
    public int incrementX() {
        x++;
        return x;
    }
}

public class Threadsafe {
    public int getTwoTimesTwo() {
        int x = 1;
        x++;
        return x*x;
    }
}

पहले में, एक ही उदाहरण पर चलने वाले दो धागे एक NotThreadsafeही एक्स देखेंगे। यह खतरनाक हो सकता है, क्योंकि धागे एक्स को बदलने की कोशिश कर रहे हैं! दूसरे में, एक ही उदाहरण पर चलने वाले दो धागे Threadsafeपूरी तरह से अलग चर देखेंगे, और एक दूसरे को प्रभावित नहीं कर सकते।

Question 5

प्रत्येक विधि मंगलाचरण के अपने स्थानीय चर होते हैं और, जाहिर है, एक विधि मंगलाचरण एक ही धागे में होता है। एक वैरिएबल जो केवल एक थ्रेड द्वारा अद्यतन किया जाता है, स्वाभाविक रूप से थ्रेड-सेफ है।

हालांकि , इस बात का पूरा ध्यान रखें कि इसका वास्तव में क्या मतलब है: केवल चर को लिखता है थ्रेड-सुरक्षित; उस वस्तु पर कॉलिंग विधि जिसे वह संदर्भित करता है वह स्वाभाविक रूप से थ्रेड-सुरक्षित नहीं है । एक ही वस्तु के चर को सीधे अद्यतन करने के लिए जाता है।

Question 6

नंबरी जैसे अन्य उत्तरों के अलावा।

मैं इंगित करना चाहता हूं कि आप anoymous प्रकार की विधि में एक स्थानीय चर का उपयोग कर सकते हैं:

इस पद्धति को अन्य थ्रेड्स में बुलाया जा सकता है जो थ्रेडसैफ़टी से समझौता कर सकता है, इसलिए जावा सभी स्थानीय चर का उपयोग करता है जो कि ऑयोमस प्रकारों में उपयोग किए जाने वाले अंतिम के रूप में घोषित किए जाते हैं।

इस अवैध कोड पर विचार करें:

public void nonCompilableMethod() {
    int i=0;
    for(int t=0; t<100; t++)
    {
      new Thread(new Runnable() {
                    public void run() {
                      i++; //compile error, i must be final:
                      //Cannot refer to a non-final variable i inside an
                      //inner class defined in a different method
                    }
       }).start();
     }
  }

यदि जावा ने इसे अनुमति दी (जैसे C # "क्लोजर" के माध्यम से करता है), तो एक स्थानीय चर अब सभी परिस्थितियों में थ्रेडसेफ़ नहीं होगा। इस स्थिति में, iसभी थ्रेड्स के अंत में मान होने की गारंटी नहीं है 100।

Question 7

धागे का अपना ढेर होगा। दो थ्रेड्स में दो स्टैक होंगे और एक थ्रेड कभी भी अपने स्टैक को अन्य थ्रेड के साथ साझा नहीं करेगा। स्थानीय चर प्रत्येक थ्रेड के अपने स्टैक में संग्रहीत होते हैं। इसका मतलब है कि थ्रेड्स के बीच स्थानीय चर कभी साझा नहीं किए जाते हैं।

Question 8

मूल रूप से चार प्रकार के भंडारण हैं जो जावा में वर्ग सूचना और डेटा संग्रहीत करने के लिए हैं:

विधि क्षेत्र, ढेर, जावा स्टैक, पीसी

इसलिए मेथड एरिया और हीप को सभी थ्रेड्स द्वारा साझा किया जाता है, लेकिन प्रत्येक थ्रेड का अपना जावा स्टैक और पीसी होता है और जिसे किसी अन्य थ्रेड द्वारा साझा नहीं किया जाता है।

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

@Weston के पास अच्छा जवाब भी है।

Question 9

थ्रेड स्टैक पर केवल स्थानीय चर संग्रहीत किए जाते हैं।

स्थानीय चर है कि primitive type(जैसे पूर्णांक, लंबे समय से ...) पर संग्रहीत किया जाता thread stackहै और इसके परिणामस्वरूप - अन्य धागा यह करने के लिए एक पहुँच नहीं है।

स्थानीय चर है कि reference type(उत्तराधिकारी के Object) 2 भागों से होता है - पता (जिस पर संग्रहीत किया जाता है thread stack) और वस्तु (जिस पर संग्रहीत किया जाता है heap)


class MyRunnable implements Runnable() {
    public void run() {
        method1();
    }

    void method1() {
        int intPrimitive = 1;

        method2();
    }

    void method2() {
        MyObject1 myObject1 = new MyObject1();
    }
}

class MyObject1 {
    MyObject2 myObject2 = new MyObject2();
}

class MyObject2 {
    MyObject3 myObject3 = MyObject3.shared;
}

class MyObject3 {
    static MyObject3 shared = new MyObject3();

    boolean b = false;
}