multithreading - java synchronization with executor framework -

इस कोड में क्या गलत है

  सार्वजनिक वर्ग SimpleThreadPool {सार्वजनिक स्थिर शून्य मुख्य (स्ट्रिंग [ ] आर्ग्स) {निष्पादक सेवा निष्पादक = निष्पादक। एनएफ़फिक्सट्रेडपूल (5); (इंट आई = 0; आई & lt; 2000; i ++) के लिए (रननबल वर्कर = नया वर्कर थ्रेड ("+ i"); executor.execute (कार्यकर्ता); } वर्कर थ्रेड ओबज = नया वर्करट्रेड (); Println (obj.getCount ()); executor.shutdown (); जबकि (! निष्पादक.सुरक्षित ()) {} System.out.println ("सभी धागे समाप्त"); }} क्लास वर्कर टू्रेड ऑप्लेट्स रननाबल {निजी स्ट्रिंग कमांड; निजी अस्थिर स्थैतिक इंट गणना; सार्वजनिक वर्कर थ्रेड () {} सार्वजनिक वर्कर थ्रेड (स्ट्रिंग्स) {this.command = s; } @ ओवरराइड पब्लिक वायड रन () {प्रयास करें {सिंक्रनाइज़ (इस) {processCommand (); }} पकड़ (बाधित ईक्सेप्शन ई) {e.printStackTrace (); }} प्राइवेट व्यर्थ प्रोसेस कॉमांड () इंटरवर्टेड एक्सपेशेशन फेंकता {count ++; System.out.println ("गणना" + गणना); //Thread.sleep(500); } @ ओवरराइड सार्वजनिक स्ट्रिंग toString () {this.command लौटें; } सार्वजनिक int getCount () {वापसी गणना; }}  

मैं 2000 के रूप में गिनती का परिणाम प्राप्त करने की कोशिश कर रहा हूं और वह भी अंत में ... मेरे कोड में क्या गलत है ?? कैसे मैं यह सुनिश्चित कर सकता हूं कि गिनती हमेशा सही क्रम में बढ़ी है ?? मुझे अस्थिर या सिंक्रनाइज़ किए गए ब्लॉक या दोनों का उपयोग कब करना चाहिए ??

आप इस पर सिंक्रनाइज़ कर रहे हैं। लेकिन जब आप ऐसा करते हैं, तो आपको प्रत्येक WorkerThread लॉक करना होता है, जो उत्पादक नहीं है।

विधि processcommand विधि परमाणु नहीं है, इसलिए आउटपुट आदेश से बाहर आओ इसके अलावा, वेतन वृद्धि भी परमाणु नहीं है; इसे मान पढ़ना, मान बढ़ा देना चाहिए, और मान को वापस चर में संग्रहीत करना होगा।

बनाना count अस्थिर केवल यह सुनिश्चित करता है कि एक अद्यतन मान

यदि आप एक ऑब्जेक्ट को सभी थ्रेडों में सिंक्रनाइज़ करते हैं ( WorkerThread.class यहां काम करेगा), फिर प्रत्येक थ्रेड अपडेट हो जाएगा और सुरक्षित रूप से प्रिंट कर देगा।

  सिंक्रनाइज़ (वर्करट्रेड। क्लास) {processCommand (); }  

यदि आप ठीक से ऊपर सिंक्रनाइज़ करते हैं, तो अस्थिर यहां आवश्यक नहीं है, हालांकि यह कुछ भी चोट नहीं पहुँचाएगा; गिनती तक पहुंच पूरी तरह से नियंत्रित है।

ध्यान दें: प्रश्न के लिखित में 2000 20000 ; यह अब प्रासंगिक नहीं है।

साथ ही, 20000 प्राप्त करने के लिए, आप शायद 20000 कार्य करना चाहते हैं; वे प्रत्येक एक बार मान बढ़ाते हैं।

  के लिए (int i = 0; i & lt; 20000; i ++) {