मल्टीकोर और जावा के बारे में बहुत झगड़ा लगता है। जबकि कुछ लोग कहते हैं कि जावा समर्थन good enough नहीं है, यह निश्चित रूप से उम्मीद करने के लिए एक क्षेत्र प्रतीत होता है। समवर्ती कार्यक्रमों के प्रदर्शन में सुधार के लिए manytechniques लगता है।मल्टीकोर परिदृश्य में जावा प्रोग्रामिंग कोडिंग की युक्तियाँ
बहु कोर परिदृश्य में प्रोग्रामिंग के बारे में कोई सुझाव/सलाह की सराहना की जाती है।
नई जावा समरूपता सुविधाओं (java.util.concurrent package में) को देखें जो जावा 5 में जोड़ा गया है। यह कार्यक्षमता प्रदान करता है जो नियमित Thread एस से अधिक उच्च स्तर है जो इसे आसान (और कम त्रुटि-प्रवण) बनाता है समवर्ती अनुप्रयोग लिखें। Lesson: ConcurrencyThe Java Tutorials शुरू करने के लिए एक अच्छी जगह होगी।
अब तक, मैं केवल ExecutorService का उपयोग किया है, जो thread pools, उत्पादन कर सकते हैं अनुमति देता है जो नए कार्य Runnable या Callable रों (जो Future रों के रूप में निष्पादन के बाद मान सकते हैं) की इकाइयों में हस्तांतरित कर दिया जा सकता है, और वास्तविक थ्रेडिंग कोड ExecutorService द्वारा संभाला जाता है।
, 2 धागे की एक धागा पूल का उपयोग कर कुछ गणना प्रदर्शन, और परिणाम हो रही है के रूप में सरल किया जा सकता है:
ExecutorService es = Executors.newFixedThreadPool(2);
Future f1 = es.submit(new Callable<Integer>() {
public Integer call()
{
// Do some processing...
return someInteger;
}
});
Future f2 = es.submit(new Callable<Integer>() {
public Integer call()
{
// Do some processing...
return someInteger;
}
});
Integer firstInteger = f1.get();
Integer secondInteger = f2.get();
ऊपर (untested) कोड में, मैं के बारे में चिंता करने की ज़रूरत है परिणाम Callable एस और submit इसे ExecutorService पर और बाद में Future एस का उपयोग करके परिणाम पुनर्प्राप्त करने के लिए बना रहा है।
पकड़ रहा है, एक बार Future की get विधि कहा जाता है, अगर प्रसंस्करण पूरा नहीं हुआ है, इस कार्यक्रम जब तक Future का परिणाम प्राप्त किए जा सकें बंद हो जाएगा। तो, इस उदाहरण में, f2 का परिणाम f1 से पहले उपलब्ध है, तो प्रोग्राम f1 के परिणाम तक प्रतीक्षा करेगा।
पढ़ने की सामग्री के मामले में, जल्द ही खरीदने के लिए किताबों की मेरी सूची पर ब्रायन गोएट्ज़ द्वारा Java Concurrency in Practice है, जो अक्सर जावा में समेकन के समय आता है।
जावा 5 दस्तावेज़ से Concurrency Utilities पृष्ठ में और जानकारी भी है।
हमेशा एक अच्छी युक्ति - यदि आपकी अधिकांश कक्षाएं अपरिवर्तनीय हैं तो सबकुछ इतना आसान हो जाता है क्योंकि अपरिवर्तनीयता चिंता के कुछ स्थानों पर ताले के बारे में चिंता करने की आवश्यकता को हटा देती है।
+1। मैं कक्षाओं को हमेशा अपरिवर्तनीय बनाने के लिए डिज़ाइन करता हूं और इसकी आवश्यकता होने पर केवल परिवर्तनीय बना देता हूं। – Fortyrunner
सबसे अच्छा टिप होना चाहिए: अपना सिंक्रनाइज़ेशन सही प्राप्त करें!
यह कुछ हद तक स्पष्ट लग सकता है, लेकिन Java Memory Model की समझ महत्वपूर्ण है, विशेष रूप से कैसे अस्थिर और अंतिम क्षेत्रों काम करते हैं, कैसे दोनों एक म्युटेक्स और एक स्मृति बाधा के रूप में कार्य करता है सिंक्रनाइज़ और उसके बाद नया java.util.concurrent भी
देवॉक्सक्स 2008 से ब्रायन गोएट्ज़ की बात From concurrent to Parallel देखें। वहां कई युक्तियां नहीं हैं, लेकिन यह आपको एक विचार देता है जहां जावा समेकन की ओर बढ़ रहा है।
व्यावहारिक सुझावों के साथ सबसे अच्छी किताब Java Concurrency in Practise है। यह सभी जावा प्रोग्रामर के लिए पढ़ा जाना चाहिए, यहां तक कि जो लोग सोचते हैं कि वे कोई समवर्ती प्रोग्रामिंग नहीं करते हैं, क्योंकि जावा के विभिन्न पुस्तकालयों में कई छिपे हुए धागे हैं (स्विंग को ध्यान में आता है, सर्वलेट के साथ ही)।
आगामी fork-join framework देखें। फोर्क-जॉइन फ्रेमवर्क डेवलपर्स को मल्टीकोर आर्किटेक्चर पर बढ़िया समांतरता प्राप्त करने में सक्षम बनाता है।
इसके अलावा आप Clojure जैसे जेवीएम आधारित भाषाओं को देखना चाह सकते हैं जो मल्टीकोर समानांतर प्रोग्रामिंग को आसान बनाने का दावा करते हैं।
समेकन के लिए जावा के अपने साझा-स्मृति दृष्टिकोण के विकल्प के रूप में आप जावा के शीर्ष पर Actor-based concurrency using Scala पर भी देख सकते हैं, जो समवर्ती प्रोग्रामिंग के लिए एक आसान मॉडल प्रदान करता है।
मेरी युक्ति: जावा मेमोरी मॉडल को समझें (जेडीके 5 और उच्चतर के बाद से)। अधिकांश लोगों को पता नहीं है कि सिंक्रनाइज़ेशन, अस्थिर, और फाइनल में सामान्य बहु-थ्रेडिंग स्कोप से परे अतिरिक्त अर्थ होता है।
जावा बहु-सीपीयू और बहु-कोर के लिए ठीक है। यदि आप इसे सही तरीके से प्रोग्राम करते हैं और आप कुछ मस्तिष्क का निवेश करते हैं, तो आपको 8-कोर का उपयोग करने के लिए अत्यधिक समवर्ती सर्वर सिस्टम मिल जाता है जिसमें बहुत सारे सिंक्रनाइज़ेशन आदि शामिल हैं। हम इसके साथ काफी खुश हैं ... जेडीके 6 जेडीके 5 से बेहतर है और नीचे सब कुछ बहु-सीपीयू मशीनों पर बेकार है।
आप जावा के लिए Skandium जैसे समांतरता पैटर्न लाइब्रेरी का उपयोग करने का प्रयास कर सकते हैं। बस समानांतरता पैटर्न चुनें जिसे आप चाहते हैं और लापता हुक भरें।
Skandium में sopported पैटर्न से कुछ हैं:
Farm<P,R>(nested);For<P,R>(nested, i);While<P,R>(nested, condition);If<P,R>(condition, trueCase, falseCase);Map<P,R>(split, nested, merge);Fork<P,R>(split, nested, merge);DaC<P,R>(condition, split, nested, merge);सभी पैटर्न घोंसला और गठबंधन किया जा सकता है, इसलिए आप एक विभाजन के अंदर खेत और जीत सकते हैं, आदि
कौन सोचता है कि यह प्रश्न रचनात्मक नहीं है? यह रचनात्मक है। – Xofo