AllOf और AnyOf को कंप्लीटटेबल सिवनी में सुधार करना

फिर से नमस्कार। पाठ्यक्रम की शुरुआत की प्रत्याशा में "जावा डेवलपर" ने आपके लिए उपयोगी सामग्री का अनुवाद तैयार किया।

---

CompletableFuture में दो विधियाँ हैं जिनकी डिज़ाइन मुझे आश्चर्यचकित करती है:

• कंप्लीटटेबल सीवन # allOf
• कंप्लीटटेबल सिवनी # anyOf

इस लेख में हम देखेंगे कि उनके साथ क्या गलत है और उन्हें कैसे अधिक सुविधाजनक बनाया जा सकता है।

कंप्लीटटेबल सीवन # allOf

आइए विधि हस्ताक्षर पर नजर डालें:

 public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs) { // ... } 

यहां कम से कम दो विवादास्पद मुद्दे हैं:

1. यह विधि कई CompletableFuture वस्तुओं को स्वीकार करती है जो विभिन्न प्रकार की वस्तुओं को CompletableFuture ।
2. मेथड CompletableFuture , जो Void देता है

इसके अलावा, कुछ पैरामीटर की चर संख्या पसंद नहीं कर सकते हैं, तो आइए इस भाग को भी देखें।

CompletableFuture<Void> अक्सर किसी ऑपरेशन को पूरा करने के लिए सिग्नल के रूप में उपयोग किया जाता है; हालाँकि, एपीआई में एक छोटा सा परिवर्तन करके, इस विधि को सिग्नलिंग डिवाइस के रूप में और सभी पूर्ण किए गए कार्यों के परिणामों के वाहक के रूप में उपयोग किया जा सकता है । चलो इसे करने की कोशिश करते हैं।

एसिंक्रोनस कंप्लीटटेबल सिवनी # ऑलऑफ

सबसे पहले, चलो सही हस्ताक्षर के साथ आते हैं।

यह मान लेना उचित है कि ज्यादातर मामलों में सजातीय CompletableFuture की एक सूची को संसाधित करना और एक CompletableFuture को वापस करना जिसमें परिणामों की सूची होगी, की आवश्यकता होगी:

 public static <T> CompletableFuture<List<T>> allOf( Collection<CompletableFuture<T>> futures) { // ... } 

मूल विधि का अंतर आपकी अपेक्षा से अधिक जटिल है:

 static CompletableFuture<Void> andTree( CompletableFuture<?>[] cfs, int lo, int hi) { CompletableFuture<Void> d = new CompletableFuture<Void>(); if (lo > hi) // empty d.result = NIL; else { CompletableFuture<?> a, b; int mid = (lo + hi) >>> 1; if ((a = (lo == mid ? cfs[lo] : andTree(cfs, lo, mid))) == null || (b = (lo == hi ? a : (hi == mid+1) ? cfs[hi] : andTree(cfs, mid+1, hi))) == null) throw new NullPointerException(); if (!d.biRelay(a, b)) { BiRelay<?,?> c = new BiRelay<>(d, a, b); a.bipush(b, c); c.tryFire(SYNC); } } return d; } 

इसलिए, इसे स्क्रैच से बनाने के बजाय, हम पुन: उपयोग करने का प्रयास करेंगे जो पहले से ही मूल विधि में है जैसे कि इसे एक पूर्ण सिग्नलिंग डिवाइस के रूप में उपयोग करने का इरादा था ... और फिर शून्य परिणाम को भविष्य की सूची में बदल दें:

 CompletableFuture<List<CompletableFuture<T>>> i = futures.stream() .collect(collectingAndThen( toList(), l -> CompletableFuture.allOf(l.toArray(new CompletableFuture[0])) .thenApply(__ -> l))); 

अभी तक तो अच्छा है। हम पाने में कामयाब रहे
CompletableFuture<List<CompletableFuture<T> > > बजाय CompletableFuture<List<CompletableFuture<T> > > CompletableFuture<Void> जो पहले से ही अच्छा है। लेकिन हमें परिणामों के साथ भविष्य की सूची की आवश्यकता नहीं है, हमें परिणामों की सूची की आवश्यकता है।

अब हम केवल सूची को संसाधित कर सकते हैं और इसमें से अवांछित भविष्य निकाल सकते हैं। कंप्लीटटेबल सिवनी # जॉइन विधियों को कॉल करना पूरी तरह से सामान्य है, क्योंकि हम जानते हैं कि वे कभी भी अवरुद्ध नहीं होंगे (इस बिंदु पर, सभी भविष्य पहले से ही पूरे हो चुके हैं):

 CompletableFuture<List<T>> result = intermediate .thenApply(list -> list.stream() .map(CompletableFuture::join) .collect(toList())); 

अब इस सब को एक अंतिम हल में मिलाते हैं:

 public static <T> CompletableFuture<List<T>> allOf( Collection<CompletableFuture<T>> futures) { return futures.stream() .collect(collectingAndThen( toList(), l -> CompletableFuture.allOf(l.toArray(new CompletableFuture[0])) .thenApply(__ -> l.stream() .map(CompletableFuture::join) .collect(Collectors.toList())))); } 

एसिंक्रोनस और फॉलिंग कम्पेटिबलफ्यूचर # allOf

यदि अपवाद हैं, तो मूल कंपोज़िबलफ़्यूज़न # allOf सभी शेष संचालन के पूरा होने की प्रतीक्षा करता है।

और अगर हम इसमें अपवाद होने पर ऑपरेशन के पूरा होने की रिपोर्ट करना चाहते हैं, तो हमें कार्यान्वयन को बदलना होगा।

ऐसा करने के लिए, CompletableFuture का एक नया उदाहरण बनाएं और ऑपरेशन के एक अपवाद के बाद मैन्युअल रूप से इसे समाप्त करें:

 CompletableFuture<List<T>> result = new CompletableFuture<>(); futures.forEach(f -> f .handle((__, ex) -> ex == null || result.completeExceptionally(ex))); 

... लेकिन तब हमें परिदृश्य से निपटने की जरूरत है जब सभी भविष्य सफलतापूर्वक पूरा हो जाएंगे। यह आसानी से बेहतर ऑलफ () पद्धति का उपयोग करके किया जा सकता है, और फिर बस भविष्य को मैन्युअल रूप से समाप्त कर सकता है:

 allOf(futures).thenAccept(result::complete); 

अब हम अंतिम समाधान बनाने के लिए सब कुछ एक साथ जोड़ सकते हैं:

 public static <T> CompletableFuture<List<T>> allOfShortcircuiting(Collection<CompletableFuture<T>> futures) { CompletableFuture<List<T>> result = new CompletableFuture<>(); for (CompletableFuture<?> f : futures) { f.handle((__, ex) -> ex == null || result.completeExceptionally(ex)); } allOf(futures).thenAccept(result::complete); return result; } 

कंप्लीटटेबल सिवनी # anyOf

आइए विधि हस्ताक्षर से शुरू करें:

 public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs) { // ... } 

हम तुरंत उन समस्याओं का पता लगा सकते हैं जो ऊपर चर्चा की गई विधि के साथ हैं:

1. विधि कई प्रकार के ऑब्जेक्ट्स वाले कई CompletableFuture वस्तुओं को स्वीकार करती है।
2. विधि एक पूर्ण प्रकार का Object युक्त एक CompletableFuture देता है।

जहां तक ​​मैं समझता हूं, CompletableFuture#allOf को एक सिग्नलिंग डिवाइस के रूप में उपयोग करने के लिए डिज़ाइन किया गया था। लेकिन CompletableFuture#anyOf इस CompletableFuture#anyOf को फॉलो नहीं करता है, CompletableFuture#anyOf CompletableFuture<Object> लौटाता है, जो कि और भी भ्रामक है।

निम्नलिखित उदाहरण पर एक नज़र डालें जहाँ मैं विभिन्न प्रकारों के डेटा युक्त कंप्लीटटेबल सिवनी को संसाधित करने का प्रयास कर रहा हूँ:

 CompletableFuture<Integer> f1 = CompletableFuture.completedFuture(1); CompletableFuture<String> f2 = CompletableFuture.completedFuture("2"); Integer result = CompletableFuture.anyOf(f1, f2) .thenApply(r -> { if (r instanceof Integer) { return (Integer) r; } else if (r instanceof String) { return Integer.valueOf((String) r); } throw new IllegalStateException("unexpected object type!"); }).join(); 

बहुत असहज है, है ना?

सौभाग्य से, हस्ताक्षर बदलने और प्रत्यक्ष प्रकार की कास्टिंग शुरू करने से अधिक सामान्य परिदृश्य (एक ही प्रकार के कई भविष्य के मूल्यों के लिए प्रतीक्षा करना) के लिए अनुकूलित करना बहुत आसान है।

इस प्रकार, हमारे सुधारों के साथ, हम मौजूदा तरीकों का पुन: उपयोग कर सकते हैं और सुरक्षित रूप से परिणाम ला सकते हैं:

 public static <T> CompletableFuture<T> anyOf(List<CompletableFuture<T>> cfs) { return CompletableFuture.anyOf(cfs.toArray(new CompletableFuture[0])) .thenApply(o -> (T) o); } public static <T> CompletableFuture<T> anyOf(CompletableFuture<T>... cfs) { return CompletableFuture.anyOf(cfs).thenApply(o -> (T) o); } 

स्रोत कोड

स्रोत कोड Github पर पाया जा सकता है।

वह सब है। कोर्स पर मिलते हैं ।