I ++ परमाणु क्यों नहीं है?

Question 1

यही वजह है कि i++जावा में परमाणु नहीं है?

जावा में थोड़ा गहरा होने के लिए मैंने यह गिनने की कोशिश की कि थ्रेड्स में लूप कितनी बार निष्पादित होता है।

इसलिए मैंने ए

private static int total = 0;

मुख्य वर्ग में।

मेरे दो सूत्र हैं।

धागा 1: प्रिंट System.out.println("Hello from Thread 1!");
धागा 2: प्रिंट System.out.println("Hello from Thread 2!");

और मैं थ्रेड 1 और थ्रेड 2 द्वारा मुद्रित पंक्तियों की गणना करता हूं। लेकिन थ्रेड 1 + थ्रेड 2 की पंक्तियाँ प्रिंट की गई लाइनों की कुल संख्या से मेल नहीं खाती हैं।

यहाँ मेरा कोड है:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Test {

    private static int total = 0;
    private static int countT1 = 0;
    private static int countT2 = 0;
    private boolean run = true;

    public Test() {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        newCachedThreadPool.execute(t1);
        newCachedThreadPool.execute(t2);
        try {
            Thread.sleep(1000);
        }
        catch (InterruptedException ex) {
            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
        }
        run = false;
        try {
            Thread.sleep(1000);
        }
        catch (InterruptedException ex) {
            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println((countT1 + countT2 + " == " + total));
    }

    private Runnable t1 = new Runnable() {
        @Override
        public void run() {
            while (run) {
                total++;
                countT1++;
                System.out.println("Hello #" + countT1 + " from Thread 2! Total hello: " + total);
            }
        }
    };

    private Runnable t2 = new Runnable() {
        @Override
        public void run() {
            while (run) {
                total++;
                countT2++;
                System.out.println("Hello #" + countT2 + " from Thread 2! Total hello: " + total);
            }
        }
    };

    public static void main(String[] args) {
        new Test();
    }
}

Question 2

i++शायद जावा में परमाणु नहीं है क्योंकि परमाणु एक विशेष आवश्यकता है जो के अधिकांश उपयोगों में मौजूद नहीं है i++। उस आवश्यकता का एक महत्वपूर्ण ओवरहेड है: एक वृद्धिशील ऑपरेशन परमाणु बनाने में एक बड़ी लागत है; इसमें सॉफ्टवेयर और हार्डवेयर दोनों स्तरों पर सिंक्रोनाइज़ेशन शामिल है जो एक साधारण वेतन वृद्धि में मौजूद नहीं है।

आप ऐसा तर्क बना सकते हैं जिसे i++विशेष रूप से एक परमाणु वेतन वृद्धि के रूप में डिजाइन और प्रलेखित किया जाना चाहिए, ताकि गैर-परमाणु वृद्धि का उपयोग किया जाए i = i + 1। हालांकि, यह जावा, और C और C ++ के बीच "सांस्कृतिक संगतता" को तोड़ देगा। इसके साथ ही, यह एक सुविधाजनक अंकन को दूर करेगा, जो सी-जैसी भाषाओं से परिचित प्रोग्रामर इसे प्रदान करते हैं, यह एक विशेष अर्थ देता है जो केवल सीमित परिस्थितियों में लागू होता है।

बेसिक सी या सी ++ कोड जैसे for (i = 0; i < LIMIT; i++)जावा में अनुवाद करेगा for (i = 0; i < LIMIT; i = i + 1); क्योंकि परमाणु का उपयोग करना अनुचित होगा i++। क्या बुरा है, जावा से सी या अन्य सी-जैसी भाषाओं से आने वाले प्रोग्रामर i++वैसे भी उपयोग करेंगे , जिसके परिणामस्वरूप परमाणु निर्देशों का अनावश्यक उपयोग होगा।

यहां तक कि मशीन अनुदेश सेट स्तर पर, एक वृद्धि प्रकार का ऑपरेशन आमतौर पर प्रदर्शन कारणों के लिए परमाणु नहीं है। X86 में, incनिर्देश परमाणु को बनाने के लिए एक विशेष निर्देश "लॉक प्रीफिक्स" का उपयोग किया जाना चाहिए : ऊपर के समान कारणों के लिए। यदि incहमेशा परमाणु थे, तो इसका उपयोग कभी नहीं किया जाएगा जब गैर-परमाणु इंक की आवश्यकता होती है; प्रोग्रामर और कंपाइलर कोड को उत्पन्न करते हैं जो लोड करता है, 1 और स्टोर जोड़ता है, क्योंकि यह तेजी से रास्ता होगा।

कुछ निर्देश सेट आर्किटेक्चर में, कोई परमाणु incया शायद incबिल्कुल भी नहीं है; MIPS पर एक परमाणु इंक करने के लिए, आप एक सॉफ्टवेयर पाश जो का उपयोग करता है लिखने के लिए है llऔर scलोड से जुड़े, और स्टोर-सशर्त:। लोड-लिंक्ड शब्द को पढ़ता है, और स्टोर-सशर्त नए मूल्य को संग्रहीत करता है यदि शब्द नहीं बदला है, या फिर यह विफल रहता है (जो पता चला है और पुन: प्रयास का कारण बनता है)।

Question 3

i++ दो ऑपरेशन शामिल हैं:

के वर्तमान मूल्य को पढ़ें i
मूल्य बढ़ाएँ और इसे असाइन करें i

जब दो धागे i++एक ही चर पर एक ही समय में प्रदर्शन करते हैं , तो वे दोनों एक ही वर्तमान मूल्य प्राप्त कर सकते हैं i, और फिर वृद्धि और इसे सेट कर सकते हैं i+1, इसलिए आपको दो के बजाय एक एकल वेतन वृद्धि मिलेगी।

उदाहरण :

int i = 5;
Thread 1 : i++;
           // reads value 5
Thread 2 : i++;
           // reads value 5
Thread 1 : // increments i to 6
Thread 2 : // increments i to 6
           // i == 6 instead of 7

Question 4

महत्वपूर्ण बात यह है कि JVM के विभिन्न कार्यान्वयनों की भाषा की एक निश्चित विशेषता को लागू किया जा सकता है या नहीं किया जा सकता है, बजाय JLS (जावा भाषा विनिर्देश)। JLS ++ 15.14.2 खंड में ++ पोस्टफिक्स ऑपरेटर को परिभाषित करता है जो कहता है कि "मान 1 को चर के मूल्य में जोड़ा जाता है और योग चर में वापस संग्रहीत होता है"। कहीं भी इसका उल्लेख या संकेत बहुपरत या परमाणु में नहीं मिलता है। इन के लिए JLS अस्थिर और प्रदान करता है सिंक्रनाइज़ । इसके अतिरिक्त, पैकेज java.util.concurrent.atomic (देखें http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/package-sumaryary.html ) है

Question 5

जावा में i ++ परमाणु क्यों नहीं है?

आइए वेतन वृद्धि ऑपरेशन को कई कथनों में तोड़ें:

धागा 1 और 2:

स्मृति से कुल का मूल्य प्राप्त करें
मान में 1 जोड़ें
स्मृति में वापस लिखें

यदि कोई सिंक्रनाइज़ेशन नहीं है, तो मान लें कि थ्रेड एक ने मान 3 पढ़ा है और इसे बढ़ाकर 4 कर दिया है, लेकिन इसे वापस नहीं लिखा है। इस बिंदु पर, संदर्भ स्विच होता है। थ्रेड दो मान 3 को पढ़ता है, इसे बढ़ाता है और संदर्भ स्विच होता है। यद्यपि दोनों थ्रेड्स ने कुल मूल्य में वृद्धि की है, यह अभी भी 4 - दौड़ की स्थिति होगी।

Question 6

i++ एक कथन है जिसमें केवल 3 ऑपरेशन शामिल हैं:

वर्तमान मूल्य पढ़ें
नया मान लिखें
नया मान संग्रहीत करें

इन तीन ऑपरेशनों को एक ही चरण में निष्पादित नहीं किया जाना चाहिए या दूसरे शब्दों i++में एक यौगिक नहीं है ऑपरेशन । परिणामस्वरूप सभी प्रकार की चीजें गलत हो सकती हैं जब एक से अधिक धागे एक ही नहीं बल्कि गैर-मिश्रित ऑपरेशन में शामिल होते हैं।

इस परिदृश्य पर विचार करें:

समय 1 :

Thread A fetches i
Thread B fetches i

समय 2 :

Thread A overwrites i with a new value say -foo-
Thread B overwrites i with a new value say -bar-
Thread B stores -bar- in i

// At this time thread B seems to be more 'active'. Not only does it overwrite 
// its local copy of i but also makes it in time to store -bar- back to 
// 'main' memory (i)

समय 3 :

Thread A attempts to store -foo- in memory effectively overwriting the -bar- 
value (in i) which was just stored by thread B in Time 2.

Thread B has nothing to do here. Its work was done by Time 2. However it was 
all for nothing as -bar- was eventually overwritten by another thread.

आखिर तुमने इसे हासिल कर ही लिया है। एक दौड़ की स्थिति।

इसलिए i++वह परमाणु नहीं है। यदि ऐसा होता, तो इसमें से कुछ भी नहीं होता और प्रत्येक fetch-update-storeपरमाणु में होता। ठीक वैसा हीAtomicInteger आपके लिए है और आपके मामले में शायद सही में फिट होगा।

पुनश्च

उन सभी मुद्दों को कवर करने वाली एक उत्कृष्ट पुस्तक और फिर कुछ इस प्रकार है: जावा कॉनएरेबिलिटी इन प्रैक्टिस

Question 7

जेवीएम में, एक वृद्धि में एक रीड एंड राइट शामिल होता है, इसलिए यह परमाणु नहीं है।

Question 8

यदि ऑपरेशन i++परमाणु होगा, तो आपको इससे मूल्य पढ़ने का मौका नहीं मिलेगा। यह वही है जो आप उपयोग करना चाहते हैं i++( उपयोग करने के बजाय ++i)।

उदाहरण के लिए निम्नलिखित कोड देखें:

public static void main(final String[] args) {
    int i = 0;
    System.out.println(i++);
}

इस मामले में हम उम्मीद करते हैं कि आउटपुट होगा: 0 (क्योंकि हम वेतन वृद्धि करते हैं, उदाहरण के लिए पहले पढ़ें, फिर अपडेट करें)

यह एक कारण है कि ऑपरेशन परमाणु नहीं हो सकता है, क्योंकि आपको मूल्य पढ़ने की ज़रूरत है (और इसके साथ कुछ करें) और फिर मूल्य को अपडेट करें।

दूसरा महत्वपूर्ण कारण यह है कि लॉकिंग के कारण आमतौर पर कुछ भी करने में अधिक समय लगता है। यह मूर्खतापूर्ण होगा कि प्राइमरी में सभी ऑपरेशन दुर्लभ मामलों के लिए थोड़ा अधिक समय लेते हैं जब लोग परमाणु संचालन करना चाहते हैं। यही कारण है कि वे जोड़ दिया है AtomicIntegerऔर अन्य भाषा के लिए परमाणु कक्षाओं।

Question 9

दो चरण हैं:

स्मृति से मुझे प्राप्त करें
i + 1 से i सेट करें

इसलिए यह परमाणु संचालन नहीं है। जब थ्रेड 1 i ++ निष्पादित करता है, और थ्रेड 2 i ++ निष्पादित करता है, तो i का अंतिम मान i + 1 हो सकता है।

Question 10

Concurrency ( Threadवर्ग और इस तरह) जावा के v1.0 में एक अतिरिक्त सुविधा है ।i++इससे पहले बीटा में जोड़ा गया था, और जैसा कि यह अभी भी इसके (अधिक या कम) मूल कार्यान्वयन में संभावना से अधिक है।

यह वैरिएबल को सिंक्रनाइज़ करने के लिए प्रोग्रामर पर निर्भर है। की जाँच करें इस पर Oracle के ट्यूटोरियल ।

संपादित करें: स्पष्ट करने के लिए, i ++ एक अच्छी तरह से परिभाषित प्रक्रिया है जो जावा से पूर्ववर्ती है, और जैसे जावा के डिजाइनरों ने उस प्रक्रिया की मूल कार्यक्षमता को बनाए रखने का निर्णय लिया।

++ ऑपरेटर को बी (1969) में परिभाषित किया गया था, जो कि जावा और थ्रेडिंग को एक टैड से पूर्ववर्ती करता है।