Java.util.concurrent.CompletableFuture वर्ग विधियों के लिए गाइड

Java में शुरू की गई कंप्लीटटेबल सीवन क्लास निष्पादन के समानांतर धागों के बीच सूचना स्थानांतरित करने के लिए एक उपकरण है। अनिवार्य रूप से, यह एक अवरुद्ध कतार है जो केवल एक संदर्भ मान को पारित करने में सक्षम है। एक नियमित कतार के विपरीत, यह एक अपवाद भी फेंकता है यदि यह संचरित मूल्य की गणना करते समय हुआ।

कक्षा में कई दर्जन विधियां होती हैं जिनमें खो जाना आसान होता है। यह आलेख इन विधियों को कई मानदंडों के अनुसार वर्गीकृत करता है ताकि वे नेविगेट करने में आसान हों।

वार्म अप के लिए, हम java.util.Function पैकेज से नए इंटरफेस पेश करेंगे, जो कई तरीकों में पैरामीटर प्रकारों के रूप में उपयोग किए जाते हैं।

//  ,   BiFunction<T, U,R> { R apply(T t, U u); } //  ,    BiConsumer<T,U> { void accept(T t, U u) } //  ,   Function<T, R> { R apply(T t); } //  ,    Consumer<T> { void accept(T t); } //  ,   Supplier<T> { T get(); } 

अच्छे पुराने रननेबल को भी याद करें:

 //  ,    Runnable { void run(); } 

ये इंटरफेस कार्यात्मक हैं, अर्थात्, इस प्रकार के मूल्यों को ऑब्जेक्ट्स के संदर्भ में और विधियों या लैम्ब्डा अभिव्यक्तियों के संदर्भ में दोनों के साथ सेट किया जा सकता है।

डेटा ट्रांसफर करने के साधन के रूप में, CompletableFuture क्लास में लिखने और पढ़ने के लिए दो उप-इंटरफेस हैं, जो बदले में प्रत्यक्ष (सिंक्रोनस) और अप्रत्यक्ष (अतुल्यकालिक) में विभाजित हैं। केवल डायरेक्ट-रीडिंग सब-इंटरफ़ेस ( java.util.concurrent.Future , जावा 5 के समय से मौजूदा) को प्रोग्रामेटिक रूप से हाइलाइट किया गया है, लेकिन वर्गीकरण प्रयोजनों के लिए यह बाकी को मानसिक रूप से अलग करने के लिए उपयोगी है। उप-इंटरफेस के इस पृथक्करण के अलावा, मैं उन बुनियादी तरीकों और विधियों को अलग करने की भी कोशिश करूंगा जो विशेष मामलों को लागू करते हैं।

संक्षिप्तता के लिए, "कंप्लीटटेबल फाउन्डेशन की वस्तु" के बजाय हम "फ्यूचर" कहेंगे। "यह फ्यूचर्स" का अर्थ है वायदा जिसमें वर्णित विधि लागू की जाएगी।

1. डायरेक्ट रिकॉर्ड इंटरफ़ेस

दो बुनियादी विधियाँ हैं, बेशक - मूल्य लिखें और अपवाद लिखें:

 boolean complete(T value) boolean completeExceptionally(Throwable ex) 

स्पष्ट शब्दार्थ के साथ।

अन्य तरीके:

 boolean cancel(boolean mayInterruptIfRunning) 

समतुल्य completeExceptionally(new CancellationException) । Java.util.concurrent.Future के साथ संगतता के लिए परिचय।

 static <U> CompletableFuture<U> completedFuture(U value) 

CompletableFuture res=new CompletableFuture(); res.complete(value) बराबर CompletableFuture res=new CompletableFuture(); res.complete(value) CompletableFuture res=new CompletableFuture(); res.complete(value) ।

 void obtrudeValue(T value) void obtrudeException(Throwable ex) 

संग्रहीत मूल्य को जबरन अधिलेखित कर देता है। पैर में खुद को गोली मारने का अचूक तरीका।

2. प्रत्यक्ष पढ़ने इंटरफ़ेस

 boolean isDone() 

चेक करता है कि क्या परिणाम पहले से ही इस वायदे को लिखा गया है।

 T get() 

प्रतीक्षा करता है यदि परिणाम अभी तक नहीं लिखा गया है, और मान लौटाता है। यदि एक अपवाद फेंक दिया गया था, तो एक निष्पादन निष्पादित होता है।

अन्य तरीके:

 boolean isCancelled() 

यदि कोई अपवाद रद्द () विधि का उपयोग करके दर्ज किया गया था, तो जांच करता है।

 T join() 

समान के रूप में मिलता है (), लेकिन एक कंप्लीट एक्सक्सेप्शन फेंकता है।

 T get(long timeout, TimeUnit unit) 

टाइमआउट के साथ get() ।

 T getNow(T valueIfAbsent) 

तुरंत परिणाम देता है। यदि परिणाम अभी तक नहीं लिखा गया है, तो valueIfAbsent पैरामीटर का मान लौटाता है।

 int getNumberOfDependents() 

इसे भरने के लिए प्रतीक्षा कर रहे अन्य कंप्लीटेबल फ़ॉइल की अनुमानित संख्या।

3. अप्रत्यक्ष रिकॉर्डिंग इंटरफ़ेस

 static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) 

आपूर्तिकर्ता फ़ंक्शन के साथ कार्य लॉन्च किया गया है, और निष्पादन का परिणाम वायदा को लिखा गया है। कार्य एक मानक थ्रेड पूल पर लॉन्च किया गया है।

 static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor) 

एक ही बात, लेकिन निष्पादक पैरामीटर द्वारा निर्दिष्ट थ्रेड पूल पर शुरू करना।

 static CompletableFuture<Void> runAsync(Runnable runnable) static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor) 

जैसा कि supplyAsync , लेकिन स्टॉक टाइप Runnable और, तदनुसार, परिणाम प्रकार Void ।

4. मध्यस्थता पठन इंटरफ़ेस

इस (और / या अन्य) वायदा को भरने पर तुरंत किसी दिए गए कार्य (प्रतिक्रिया) को करने के लिए निर्धारित करता है। सबसे व्यापक उप-इंटरफ़ेस। हम इसके घटकों को दो संकेतों के अनुसार वर्गीकृत करते हैं:

a) एक भरने की प्रतिक्रिया शुरू करने का एक तरीका: फ्यूचर्स को भरते समय, या थ्रेड पूल पर कार्य के रूप में एसिंक्रोनस रूप से इसे एक विधि के रूप में सिंक्रोनाइज़ करना संभव है। एक एसिंक्रोनस शुरुआत के मामले में, प्रत्यय Async के साथ तरीकों का उपयोग किया जाता है (दो संस्करणों में, सामान्य थ्रेड ForkJoinPool.commonPool() पर शुरू ForkJoinPool.commonPool() , या एक अतिरिक्त पैरामीटर द्वारा निर्दिष्ट स्ट्रीम पर)। केवल सिंक्रोनस को चलाने की विधियाँ नीचे बताई गई हैं।

ख) इस वायदा और उसके भरने की प्रतिक्रिया के बीच संबंध की टोपोलॉजी: रैखिक, "कोई" टाइप करें और "सभी" टाइप करें।

- रैखिक संबंध: एक वायदा प्रतिक्रिया के लिए एक मूल्य बचाता है

- "कोई भी" विधि - इनपुट पर दो या अधिक वायदा; फ्यूचर्स में से एक में दिखाई देने वाला पहला (समय में) परिणाम प्रतिक्रिया में स्थानांतरित हो जाता है; अन्य परिणामों की अनदेखी की जाती है

- "सभी" विधि - इनपुट पर दो या अधिक वायदा; सभी वायदा के परिणाम जमा होते हैं और फिर प्रतिक्रिया में स्थानांतरित कर दिए जाते हैं।

4.1 इस वायदा (रैखिक संबंध) को भरने के लिए प्रतिक्रिया करें

इन विधियों में तत्कालीन उपसर्ग के साथ शुरू होने वाले नाम होते हैं, एक पैरामीटर होता है - प्रतिक्रिया, और प्रतिक्रिया के परिणाम तक पहुंचने के लिए टाइप CompletableFuture नए वायदा लौटाते हैं। वे प्रतिक्रिया के प्रकार में भिन्न होते हैं।

 <U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn) 

मुख्य विधि जिसमें एक प्रतिक्रिया को दिए गए वायदा से एक मूल्य प्राप्त होता है और परिणामी वायदा को वापसी मूल्य दिया जाता है।

 CompletableFuture<Void> thenAccept(Consumer<? super T> block) 

प्रतिक्रिया को दिए गए वायदा से मूल्य मिलता है, लेकिन मूल्य वापस नहीं करता है, इसलिए
परिणामी फ्यूचर्स का मूल्य प्रकार Void ।

 CompletableFuture<Void> thenRun(Runnable action) 

प्रतिक्रिया एक मान प्राप्त या वापस नहीं करती है।

Compute1..compute4 को विधि सन्दर्भ दें। चरण से चरण तक मूल्यों के हस्तांतरण के साथ एक रैखिक श्रृंखला इस तरह दिख सकती है:

 supplyAsync(compute1) .thenApply(compute2) .thenApply(compute3) .thenAccept(compute4); 

जो एक साधारण कॉल के बराबर है

 compute4(compute3(compute2(compute1()))); 

 <U> CompletableFuture<U> thenCompose(Function<? super T, CompletableFuture<U>> fn) 

thenApply समान रूप से, लेकिन प्रतिक्रिया स्वयं तैयार मूल्य के बजाय वायदा करती है। यदि आपको जटिल टोपोलॉजी की प्रतिक्रिया का उपयोग करने की आवश्यकता है, तो यह आवश्यक हो सकता है।

4.2 किसी भी फ्यूचर को पॉप्युलेट करने के लिए रिएक्शन करें

 static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs) 

एक नया वायदा लौटाता है जो cfs पैरामीटर द्वारा पारित किए गए किसी भी वायदा से cfs । परिणाम पूर्ण वायदा के परिणाम के साथ मेल खाता है।

4.3 दो वायदा में से किसी एक को पॉप्युलेट करने के लिए एक प्रतिक्रिया करें

मुख्य विधि:

 <U> CompletableFuture<U> applyToEither(CompletableFuture<? extends T> other, Function<? super T,U> fn) 

एक नया वायदा लौटाता है जो तब भरा जाता है जब यह वायदा या वायदा other पैरामीटर द्वारा निर्दिष्ट किया जाता है। परिणाम पूर्ण वायदा के परिणाम के साथ मेल खाता है।

विधि अभिव्यक्ति के बराबर है:

 CompletableFuture.anyOf(this, other).thenApply(fn); 

अन्य दो विधियाँ केवल प्रतिक्रिया के प्रकार में भिन्न होती हैं:

 CompletableFuture<Void> acceptEither(CompletableFuture<? extends T> other, Consumer<? super T> block) CompletableFuture<Void> runAfterEither(CompletableFuture<?> other, Runnable action) 

यह स्पष्ट नहीं है कि 3 * या तो तरीके करना आवश्यक था (9 खाते में लेना * Async विकल्प), जब कोई पर्याप्त होगा:

 <T> CompletableFuture<T> either(CompletableFuture<? extends T> other) { return CompletableFuture.anyOf(this, other); } 

तब इन सभी तरीकों को व्यक्त किया जा सकता है:

 f1.applyToEither(other, fn) == f1.either(other).thenApply(fn); f1.applyToEitherAsync(other, fn) == f1.either(other).thenApplyAsync(fn); f1.applyToEitherAsync(other, fn, executor) == f1.either(other).thenApplyAsync(fn, executor); f1.acceptEither(other, block) == f1.either(other).thenAccept(other); f1.runAfterEither(other, action) == f1.either(other).thenRun(action); 

आदि इसके अलावा, या तो अन्य संयोजनों में इस्तेमाल किया जा सकता है।

4.4 दो वायदा करने के लिए एक प्रतिक्रिया करें

 <U,V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn) 

मुख्य विधि। यह इनपुट पर दो वायदा करता है, जिसके परिणाम संचित होते हैं और फिर प्रतिक्रिया में स्थानांतरित होते हैं, जो दो मापदंडों का एक कार्य है।

प्रतिक्रिया के प्रकार में अन्य विधियां भिन्न हैं:

 <U> CompletableFuture<Void> thenAcceptBoth(CompletableFuture<? extends U> other, BiConsumer<? super T,? super U> block) 

प्रतिक्रिया एक मूल्य नहीं लौटाती है

 CompletableFuture<Void> runAfterBoth(CompletableFuture<?> other, Runnable action) 

प्रतिक्रिया कोई पैरामीटर नहीं लेती है और एक मान नहीं लौटाती है

4.5 कई फ्यूचर को पॉप्युलेट करने के लिए रिएक्शन करें

 static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs) 

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

4.6। रनटाइम त्रुटियों की अवरोधन

यदि किसी स्तर पर वायदा असामान्य रूप से समाप्त हो जाता है, तो अपवाद को वायदा श्रृंखला के नीचे पारित किया जाता है। त्रुटि का जवाब देने और सामान्य निष्पादन पर लौटने के लिए, आप अपवादों को पकड़ने के तरीकों का उपयोग कर सकते हैं।

 CompletableFuture<T> exceptionally(Function<Throwable,? extends T> fn) 

यदि यह वायदा असामान्य रूप से समाप्त हो जाता है, तो परिणामी वायदा fn फ़ंक्शन द्वारा उत्पन्न परिणाम के साथ समाप्त हो जाता है। यदि यह वायदा सामान्य रूप से समाप्त हो जाता है, तो परिणामी वायदा समान परिणाम के साथ सामान्य रूप से समाप्त हो जाता है।

 <U> CompletableFuture<U> handle(BiFunction<? super T,Throwable,? extends U> fn) 

इस पद्धति में, प्रतिक्रिया को हमेशा कहा जाता है, भले ही वायदा सामान्य या असामान्य रूप से समाप्त हो गया हो। यदि परिणाम r साथ वायदा सामान्य रूप से समाप्त हो जाता है, तो मापदंडों (r, null) को प्रतिक्रिया में स्थानांतरित किया जाएगा, अगर यह अपवाद पूर्व के साथ विफल रहता है, तो पैरामीटर (null, ex) प्रतिक्रिया में स्थानांतरित हो जाएगा। प्रतिक्रिया का परिणाम इस वायदा के परिणाम से भिन्न प्रकार का हो सकता है।

निम्न उदाहरण http://nurkiewicz.blogspot.ru/2013/05/java-8-definitive-guide-to.html से लिया गया है:

 CompletableFuture<Integer> safe = future.handle((r, ex) -> { if (r != null) { return Integer.parseInt(r); } else { log.warn("Problem", ex); return -1; } }); 

यहां, future String या त्रुटि के प्रकार के परिणामस्वरूप उत्पन्न होता है, प्रतिक्रिया परिणाम को पूर्णांक में बदल देती है, और त्रुटि के मामले में, -1 ध्यान दें कि, सामान्य रूप से सत्यापन शुरू होना चाहिए if (ex!=null) , क्योंकि r==null दोनों असामान्य और सामान्य समाप्ति के दौरान हो सकते हैं, लेकिन इस उदाहरण में r==null त्रुटि माना जाता है।

यदि कुछ समस्याओं को हल करने के लिए प्रस्तावों के रूप में रुचि दिखाई जाती है, तो एक निरंतरता होगी।