जावा में थ्रेड बिल्डिंग ब्लॉक के समान समानांतर कार्य ढांचा है - इसे फोर्क-जॉइन फ्रेमवर्क कहा जाता है। वर्तमान जावा एसई 6 के साथ उपयोग के लिए यह available है और आगामी जावा एसई 7 में शामिल किया जाना है।
जावडोक क्लास प्रलेखन के अलावा ढांचे के साथ शुरू करने के लिए संसाधन उपलब्ध हैं। jsr166 page से, उल्लेख किया गया है कि "इन वर्गों के लिए अतिरिक्त दस्तावेज, नोट्स, सलाह, उदाहरण आदि जैसे विकी भी हैं।"
fork-join examples, जैसे मैट्रिक्स गुणा शुरू करने के लिए एक अच्छी जगह है।
मैंने Intel's 2009 threading challenges में से कुछ को हल करने में फोर्क-जॉइन फ्रेमवर्क का उपयोग किया। ढांचा हल्का और कम ओवरहेड है - मेरा काइट की टूर समस्या के लिए एकमात्र जावा प्रविष्टि थी और यह प्रतिस्पर्धा में अन्य प्रविष्टियों से बेहतर प्रदर्शन करती थी। जावा स्रोत और लेखन चुनौती साइट से डाउनलोड के लिए उपलब्ध हैं।
संपादित करें:
मैं पता नहीं कैसे एक वर्ग या टुकड़े कोड एक पूल पर इसे धक्का देने के बाद लग सकता है की [...]
आप अपनी खुद की कार्य कर सकते हैं ForKJoinTask सबक्लास, जैसे कि RecursiveTask में से एक को उपclassing द्वारा। यहां समानांतर में fibonacci अनुक्रम की गणना करने का तरीका बताया गया है। (RecursiveTask javadocs से लिया - टिप्पणियां मेरे हैं।)
// declare a new task, that itself spawns subtasks.
// The task returns an Integer result.
class Fibonacci extends RecursiveTask<Integer> {
final int n; // the n'th number in the fibonacci sequence to compute
Fibonnaci(int n) { this.n = n; } // constructor
Integer compute() { // this method is the main work of the task
if (n <= 1) // 1 or 0, base case to end recursion
return n;
Fibonacci f1 = new Fibonacci(n - 1); // create a new task to compute n-1
f1.fork(); // schedule to run asynchronously
Fibonacci f2 = new Fibonacci(n - 2); // create a new task to compute n-2
return f2.invoke() + f1.join(); // wait for both tasks to compute.
// f2 is run as part of this task, f1 runs asynchronously.
// (you could create two separate tasks and wait for them both, but running
// f2 as part of this task is a little more efficient.
}
}
फिर आप इस कार्य को चलाने के लिए और परिणाम
// default parallelism is number of cores
ForkJoinPool pool = new ForkJoinPool();
Fibonacci f = new Fibonacci(100);
int result = pool.invoke(f);
यह एक तुच्छ उदाहरण चीजों को सरल रखना है मिलता है। अभ्यास में, प्रदर्शन इतना अच्छा नहीं होगा, क्योंकि कार्य द्वारा निष्पादित कार्य कार्य ढांचे के ऊपरी हिस्से की तुलना में मामूली है। अंगूठे के नियम के रूप में, एक कार्य को कुछ महत्वपूर्ण गणना करना चाहिए - फ्रेमवर्क ओवरहेड को महत्वहीन बनाने के लिए पर्याप्त, अभी तक इतना नहीं है कि आप एक बड़े कार्य को चलाने में समस्या के अंत में एक कोर के साथ समाप्त हो जाएं। छोटे कार्यों को छोटे से विभाजित करना सुनिश्चित करता है कि एक कोर बहुत सारे काम नहीं कर रहा है जबकि अन्य कोर निष्क्रिय हैं - छोटे कार्यों का उपयोग करके अधिक कोर व्यस्त रहता है, लेकिन इतना छोटा नहीं है कि कार्य कोई वास्तविक काम नहीं करता है।
[...] या अजीब कोड लग सकता है कि कैसे जब तुम सब कुछ की एक प्रतिलिपि बनाने की जरूरत है और कैसे सब कुछ के ज्यादा एक पूल पर धकेल दिया जाता है।
केवल कार्य स्वयं को पूल में धकेल दिया जाता है। आदर्श रूप में आप कुछ भी कॉपी नहीं करना चाहते हैं: हस्तक्षेप से बचने और लॉक करने की आवश्यकता से बचने के लिए, जो आपके प्रोग्राम को धीमा कर देगा, आपके कार्यों को आदर्श रूप से स्वतंत्र डेटा के साथ काम करना चाहिए। केवल पढ़ने के लिए डेटा को सभी कार्यों के बीच साझा किया जा सकता है, और इसकी प्रतिलिपि बनाने की आवश्यकता नहीं है। अगर धागे को कुछ बड़ी डेटा संरचना बनाने के लिए सह-संचालन करने की आवश्यकता होती है, तो यह सबसे अच्छा है कि वे अलग-अलग टुकड़े बनाते हैं और फिर अंत में उन्हें गठबंधन करते हैं। संयोजन को एक अलग कार्य के रूप में किया जा सकता है, या प्रत्येक कार्य पहेली के टुकड़े को समग्र समाधान में जोड़ सकता है। इसे अक्सर लॉकिंग के कुछ रूप की आवश्यकता होती है, लेकिन यदि कार्य का कार्य समाधान अद्यतन करने के काम से कहीं अधिक है तो यह काफी प्रदर्शन मुद्दा नहीं है। माई नाइट का टूर समाधान बोर्ड पर पर्यटन के एक सामान्य भंडार को अद्यतन करने के लिए इस दृष्टिकोण को लेता है।
कार्यों और समेकन के साथ काम करना नियमित एकल-थ्रेडेड प्रोग्रामिंग से काफी प्रतिमान है। किसी दिए गए समस्या को हल करने के लिए अक्सर कई डिज़ाइन संभव होते हैं, लेकिन इनमें से कुछ केवल थ्रेडेड समाधान के लिए उपयुक्त होंगे। बहु-थ्रेडेड तरीके से परिचित समस्याओं को पुन: पेश करने के तरीके को महसूस करने में कुछ प्रयास किए जा सकते हैं। सीखने का सबसे अच्छा तरीका उदाहरणों को देखना है, और फिर इसे अपने लिए आज़माएं। हमेशा प्रोफ़ाइल, और धागे की संख्या को बदलने के प्रभावों का आकलन करें। पूल कन्स्ट्रक्टर में पूल में उपयोग करने के लिए आप स्पष्ट रूप से धागे (कोर) की संख्या निर्धारित कर सकते हैं। जब कार्य रैखिक रूप से टूट जाते हैं, तो आप धागे की संख्या बढ़ने के साथ निकट रैखिक गति की उम्मीद कर सकते हैं।