मैं जावा जीयूआई संचालित अनुप्रयोग को डिजाइन करने की प्रक्रिया में हूं जो कई अलग-अलग कार्यों को चलाता है, प्रत्येक अपने स्वयं के स्विंगवर्कर विस्तारित वर्ग के भीतर। यह सामान्य डिजाइन है जिसका उपयोग मैं अपने धागे पर कार्यों को चलाने के लिए करता हूं और फिर भी ईडीटी को जीयूआई अपडेट करने के लिए स्वतंत्र रखता हूं। प्रत्येक SwingWorker एक निष्पादक का उपयोग कर अपने धागे पर शुरू किया गया है। NewCachedThreadPool।जावा स्विंगवर्कर और एकाधिक धागे
हालांकि, एक विशेष कक्षा के भीतर, एक ऐसा कार्य है जिसके लिए प्रक्रिया करने में काफी समय लगता है। कार्य में एक लूप होता है जो छह गुना तक कुछ गणना करता है।
मेरे पास प्रसंस्करण समय को तेज करने के लिए अपने स्वयं के धागे के भीतर छः गणनाओं में से प्रत्येक को लागू करने का विचार था, लेकिन मुझे यह लागू करने का सबसे अच्छा तरीका नहीं है।
क्या स्विंगवर्कर का विस्तार करना और रननेबल को लागू करना संभव है, और उसके बाद लूप के भीतर एक शून्य रन() विधि का उपयोग करें, प्रत्येक बार एक नया थ्रेड शुरू करें, या कैश किए गए थ्रेडपूल का उपयोग करें।
या क्या मैं मानक थ्रेड() कार्यान्वयन का उपयोग कर बेहतर हूं?
कोई सलाह या सुझाव की सराहना की जाएगी।
अग्रिम धन्यवाद
जोश
* "मैंने प्रसंस्करण समय को तेज करने के लिए अपने स्वयं के धागे के भीतर छः गणनाओं में से प्रत्येक को लागू करने का विचार किया है" * [एसआईसी] ... सीपीयू-बाध्य ऐप को गति देने के लिए समानांतर गणना इस तरह की होगी यदि आप अपने ऐप को चलाने वाले सीपीयू पर अपने जावा ऐप में कम से कम 6 कोर उपलब्ध हैं तो एक स्पीडअप लाएं। यदि आपको केवल दो कोर कहते हैं, तो दो के बजाए 6 धागे फैलाने से वास्तव में आपके प्रोग्राम को धीमा कर दिया जाएगा ... – TacticalCoder
आह हाँ, यह सही मायने रखता है !! धन्यवाद। –
@ user988052 जो कोई समझ नहीं आता है। यदि आपके पास एक्स धागे हैं, तो प्रोग्राम को तेज़ी से चलाने के लिए आपको कम से कम x कोर की आवश्यकता नहीं है। जब तक कि 1 से अधिक लॉजिकल सीपीयू JVM के लिए उपलब्ध हो, तब तक ओएस उन तार्किक CPUs के बीच उन धागे को फैलाने का प्रयास करेगा। अधिक तार्किक CPUs - >> प्रति सीपीयू कम धागे - >> तेजी से खत्म होता है। यह उससे कहीं अधिक जटिल हो सकता है (उदाहरण के लिए, जब कुछ ताले शामिल होते हैं), मुझे पता है, लेकिन यह आमतौर पर इस तरह से काम करता है। –