कुछ समय पहले, मैं जावा 7 में नवाचारों की समीक्षा कर रहा था, और, अन्य चीजों के अलावा, कुछ नवाचारों पर अधिक विशेष रूप से जाने की धमकी दी। काफी समय बीत गया, जावा 7 में वे एक गंभीर दोष खोजने में भी कामयाब रहे, लेकिन आखिरकार वह क्षण आया जब हमारे वादे को पूरा करने का समय आ गया। इसलिए, कटौती के तहत आप एक विवरण और नए कार्यान्वयन का उपयोग करने का एक उदाहरण पा सकते हैं ExecutorService ExecutorService बुलाया गया ForkJoinPool ForkJoinPool । इस कार्यान्वयन को विशेष रूप से पुनरावर्ती कार्यों के समानांतरीकरण को सरल बनाने के लिए डिज़ाइन किया गया है और इस समस्या को हल करता है कि जब उप-कार्य निष्पादित किया जा रहा है, तो जो थ्रेड उत्पन्न होता है उसका उपयोग नहीं किया जा सकता है।

उपयोग किए गए प्रकारों का संक्षिप्त विवरण

ForkJoinTask

यह एक अमूर्त वर्ग है, जो एक अर्थ में, एक धारा का एक हल्का एनालॉग है। लब्बोलुआब यह है कि ForkJoinPool के लिए धन्यवाद, जिसके बारे में नीचे चर्चा की जाएगी, आप थ्रेड्स की एक छोटी संख्या में काफी बड़ी संख्या में कार्य कर सकते हैं। यह तथाकथित कार्य-चोरी द्वारा प्राप्त किया जाता है, जब नींद का कार्य वास्तव में सो नहीं रहा है, लेकिन अन्य कार्यों का प्रदर्शन कर रहा है। इस वर्ग के कई दिलचस्प तरीके हैं, लेकिन हम केवल दो पर ध्यान केंद्रित करेंगे: fork() , जो अतुल्यकालिक कार्य लॉन्च और join() , जो कार्य को पूरा करने के लिए इंतजार करता है और इसके निष्पादन का परिणाम देता है। सभी तरीकों का अधिक विस्तृत विवरण आधिकारिक दस्तावेज में पाया जा सकता है।

RecursiveAction और RecursiveTask

अपने आप से, इस वर्ग का व्यावहारिक रूप से उपयोग नहीं किया जाता है, क्योंकि अधिकांश कार्यों के लिए पहले से ही अधिक विशिष्ट कार्यान्वयन तैयार हैं: RecursiveAction मामले में RecursiveAction आपको किसी भी मूल्य की गणना करने की आवश्यकता नहीं है, लेकिन आपको बस कुछ कार्रवाई करने की आवश्यकता है, और RecursiveTask RecursiveTask , जब आपको अभी भी कुछ वापस करने की आवश्यकता है। जैसा कि आप देख सकते हैं, ये दो वर्ग मौजूदा लोगों के समान हैं। Runnable Runnable और Callable Callable ।

ForkJoinPool

इस वर्ग में, वास्तविक प्रवाह के बीच लोड संतुलन के मुश्किल तर्क को लागू किया जाता है। सिद्धांत रूप में, बाहर से यह लगभग धागे के एक नियमित नियमित पूल जैसा दिखता है, और उपयोग में कोई विशेष विशेषताएं नहीं हैं।

फ्रेमवर्क का उपयोग करने का एक उदाहरण

हम एक कार्य के साथ आएंगे: हमारे पास नोड्स में लिखे संख्याओं के साथ कुछ पेड़ हैं। ऐसी सभी संख्याओं के योग की गणना करना आवश्यक है। आपसी समझ को बेहतर बनाने के लिए, मैं ट्री नोड इंटरफ़ेस दूंगा:

 public interface Node { Collection<Node> getChildren(); long getValue(); } 

अब हम एक पुनरावर्ती कार्य का वर्णन करते हैं, जो कई थ्रेड्स में आवश्यक राशि की गणना करता है, जिसे रिकर्सिवटैस्क से विरासत में मिला है। हमें केवल गणना विधि को ओवरराइड करने और fork() उपयोग करने और बुद्धिमानी से तरीकों में join :

 public class ValueSumCounter extends RecursiveTask<Long>{ private final Node node; public ValueSumCounter(Node node) { this.node = node; } @Override protected Long compute() { long sum = node.getValue(); List<ValueSumCounter> subTasks = new LinkedList<>(); for(Node child : node.getChildren()) { ValueSumCounter task = new ValueSumCounter(child); task.fork(); //   subTasks.add(task); } for(ValueSumCounter task : subTasks) { sum += task.join(); //       } return sum; } } 

यह आसान है, है ना? यह केवल एक अलग ForkJoinPool में इस खुशी को चलाने के लिए बनी हुई है:

 public static void main(String[] args) { Node root = getRootNode(); new ForkJoinPool().invoke(new ValueSumCounter(root)); } 

और आप कर रहे हैं, अपनी जेब में गणना का परिणाम!

मुझे इसकी आवश्यकता क्यों है?

सबसे पहले, Future<T> का उपयोग करने की तुलना में लेखन इतना अधिक सुविधाजनक और सहज है। इसके अलावा, जैसा कि मैंने पहले लिखा था, कांटा-नाक वाले कार्य करने के लिए एक समर्पित वास्तविक धागा बिल्कुल भी आवश्यक नहीं है। इसके विपरीत, पहले से मौजूद थ्रेड्स जो वर्तमान में शामिल हैं, सक्रिय रूप से उपयोग किए जाते हैं। यह, जाहिर है, उत्पादकता में उल्लेखनीय वृद्धि देता है। मैंने बेंचमार्क का संचालन शुरू नहीं किया, क्योंकि मुझे यकीन है कि ओरेकल के इंजीनियरों ने पहले ही मेरे लिए ऐसा किया था।

जावा 7 के साथ अपने शोध में सफलता :)