जावा थ्रेड के साथ असंगत परिणाम

Question

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

मेरी मशीन विंडोज 7, 64 बिट है।

public class ThreadClass implements Runnable { 

     int counter = 0; 

     @Override 
     public void run() { 
      add(); 
      sub(); 
     } 

     public synchronized void add() { 
      System.out.println("ADD counter" + (counter = counter + 1)); 
     } 

     public synchronized void sub() { 
      System.out.println("SUB counter" + (counter = counter - 1)); 
     } 
    } 

Testclass

public class ThreadTest { 

    public static void main(String args[]) { 
     ThreadClass tc = new ThreadClass(); 
     Thread tc0 = new Thread(tc); 
     tc0.start(); 
     tc0.setPriority(Thread.MAX_PRIORITY); 
     Thread tc1 = new Thread(tc); 
     tc1.start(); 
     tc1.setPriority(Thread.NORM_PRIORITY); 
     Thread tc2 = new Thread(tc); 
     tc2.start(); 
     tc2.setPriority(Thread.MIN_PRIORITY); 
    } 
} 

परिणाम

ADD counter1 
ADD counter2 
SUB counter1 
SUB counter0 
ADD counter1 
SUB counter0 

नोट: आप रन की जोड़ी करने के लिए इस विसंगति का उत्पादन करने की आवश्यकता हो सकती।

Answer 1

सिंक्रनाइज़ेशन का वास्तव में यह अर्थ होगा कि सभी थ्रेड सिंक्रनाइज़ किए गए ब्लॉक में प्रवेश करने से पहले लॉक प्राप्त करने के लिए प्रतीक्षा कर देंगे। केवल एक थ्रेड में ऑब्जेक्ट पर लॉक हो सकता है, इसलिए केवल एक थ्रेड add() या sub() विधियों में हो सकता है।

हालांकि, यह धागे के क्रम के बारे में कुछ और नहीं दर्शाता है। आप तीन धागे शुरू कर रहे हैं - एकमात्र गारंटी यह है कि वे add या sub विधियों को एक साथ चलाकर एक-दूसरे पर चिपक नहीं पाएंगे। थ्रेड 1 add() पर कॉल कर सकता है, फिर थ्रेड 3 add() पर कॉल कर सकता है, फिर थ्रेड 2 add() पर कॉल कर सकता है, फिर वे सभी sub() पर कॉल कर सकते हैं। या वे सभी add() और फिर sub() प्रत्येक कॉल कर सकते हैं।या कोई मिश्रण - एकमात्र आवश्यकता यह है कि प्रत्येक थ्रेड add() को sub() पर कॉल करने से पहले कॉल करता है और यह कि कोई भी दो धागे कभी भी add() या sub() पर कॉल नहीं करेंगे जबकि एक अन्य थ्रेड उस विधि में है।

एक तरफ: यह हो सकता है, कुछ मामलों में, बुरा रूप this पर सिंक्रनाइज़ करने के लिए, यह सार्वजनिक हो के रूप में - यह अक्सर पर लॉक करने के लिए एक आंतरिक निजी Object उपयोग करने के लिए इतना है कि कोई अन्य कॉल अपने लॉक ले जा सकते हैं को प्राथमिकता दी है और किसी भी ताला का उल्लंघन रणनीतियों को आपने डिजाइन किया है।

Answer 2

आपके परिणाम सही दिखते हैं।

विधियों के निष्पादन के दौरान, ऑब्जेक्ट पर एक विशेष लॉक प्राप्त किया जाता है, लेकिन add() और sub() कॉल के बीच, थ्रेड स्वतंत्र रूप से अंतःस्थापित हो सकते हैं।

यदि आप सभी धागे चलाने के बाद कुल 0 के साथ समाप्त होते हैं, तो उनमें से कोई भी ईथोर को ओवरराइट नहीं करता है और counter तक पहुंच सिंक्रनाइज़ किया गया था।

आप counter नहीं रखना चाहती हैं केवल 0 से 1 क्रमिक रूप से करने के लिए और हिट 2 कभी नहीं जाना है, तो निम्न कार्य (विधि-स्तरीय तुल्यकालन इतने लंबे समय के रूप में कोई अन्य वर्गों शामिल कर रहे हैं निरर्थक प्रस्तुत करना देंगे):

@Override 
public void run() { 
    synchronize(this) { 
     add(); 
     sub(); 
    } 
} 

हालांकि, यह थ्रेड के पूरे बिंदु को बेकार बनाता है क्योंकि आप इसे एकल-थ्रेडेड लूप में कर सकते हैं।

Answer 3

परिणामों के सेट के साथ कुछ भी गलत नहीं है। वे आपके कोड के साथ पूरी तरह से संगत हैं। एकाधिक धागे के चल रहे क्रम की गारंटी नहीं है।

आपकी 'सिंक्रनाइज़' विधियां सुनिश्चित करती हैं कि आपको वैध परिणाम मिलते हैं - add पर प्रत्येक कॉल वास्तव में एक और प्रत्येक कॉल को sub पर वास्तव में घटा देता है। उनके बिना, आप शून्य के अलावा अंतिम परिणाम प्राप्त कर सकते हैं।