मैं CompletableFuture एपीआई को समझने की कोशिश कर रहा हूं, और मैं निम्नलिखित समस्या पर फंस गया हूं।

allOf अपने आप में केवल एक CompletableFuture<void> देता है, इसलिए यह केवल allResultsOf नामक फ़ंक्शन के साथ थोड़ा बेहतर इंटरफ़ेस रखने के लिए समझ में आता है: ऐसा फ़ंक्शन सामान्य होना चाहिए, और प्रकार की तर्क वस्तुओं के रूप में प्राप्त करना चाहिए List<CompletableFuture<T>> और एक प्रकार की वस्तु लौटाएं CompletableFuture<List<T>>

इस समारोह घोषणा पर मेरा प्रयास था:

public static CompletableFuture<List<T>> allResultsOf(List<CompletableFuture<T>> completableFutures) {
                CompletableFuture<Void> allFutures = CompletableFuture
                .allOf(completableFutures.toArray(new CompletableFuture[completableFutures.size()]));
    
                CompletableFuture<List<T>> allCompletableFuture = allFutures.thenApply(
                    future -> {
                        return completableFutures.stream()
                            .map(completableFuture -> completableFuture.join())
                            .collect(Collectors.toList());
                });
    
                return allCompletableFuture;
            }

हालांकि, मेरे (संलग्न) उदाहरण स्निपेट में, यह फ़ंक्शन इस संकलन त्रुटि देता है:

त्रुटि: असंगत प्रकार: सूची> को List> CompletableFuture allCompletableFuture = allResultsOf(completableFutures) में परिवर्तित नहीं किया जा सकता है;

मुझे यकीन नहीं है कि यहाँ क्या समस्या है

उदाहरण कोड (यहां से निकाला गया ):

import java.util.*;
import java.util.stream.*;
import java.lang.*;
import java.io.*;
import java.util.concurrent.*;

// The main method must be in a class named "Main".
class Main {
    static class Test {
        private ExecutorService executor;
        public Test(ExecutorService es) {
            executor = es;
        }
        public class GreetHolder {

            private String greet;
        
            public GreetHolder(String greet) {
                this.greet = greet;
            }
        
            public String getGreet() {
                return greet;
            }
        
            public void setGreet(String greet) {
                this.greet = greet;
            }
            
            public String toString() {
                return getGreet();
            }
        }
        
        private CompletableFuture<GreetHolder> getGreeting(String lang) {
            return CompletableFuture.supplyAsync( () -> {
                try {
                    System.out.println("Task execution started for lang =" + lang);
                    Thread.sleep(200);
                    System.out.println("Task execution stopped for lang =" + lang);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return new GreetHolder(getGreet(lang));
            }, executor);
        }
        public String getGreet(String lang) {
            if (lang.equals("EN")) {
                return "Hello";
            } else if (lang.equals("ES")) {
                return "Hola";
            } else if (lang.equals("SN")) {
                return "Ayubovan";
            } else {
                throw new IllegalArgumentException("Invalid lang param");
            }
        }
        
        public CompletableFuture<List<Test.GreetHolder>> run() {
            List<String>  langList = Arrays.asList("EN", "ES", "SN"); //, "EX");

            List<CompletableFuture<Test.GreetHolder>> completableFutures =
            langList.stream().map(lang -> getGreeting(lang))
                //.map(CompletableFuture::join);
                .collect(Collectors.toList());
            
            // return completableFutures;
            
            CompletableFuture<Void> allFutures = CompletableFuture
            .allOf(completableFutures.toArray(new CompletableFuture[completableFutures.size()]));
            
            CompletableFuture<List<GreetHolder>> allCompletableFuture = allFutures.thenApply(
                future -> {
                    System.out.println(String.format("%s <- future", future));
                    return completableFutures.stream()
                        .map(completableFuture -> completableFuture.join())
                        .collect(Collectors.toList());
            });
            
            System.out.println(String.format("%s <- allCompletableFuture", allCompletableFuture));
            
            //return allCompletableFuture;
            
            
            CompletableFuture completableFuture = allCompletableFuture.thenApply(
                greets -> {
                       return greets
                            .stream()
                            .map(GreetHolder::getGreet)
                            .collect(Collectors.toList());
            });
            return completableFuture;
            
            
        }

        public static CompletableFuture<List<T>> allResultsOf(List<CompletableFuture<T>> completableFutures) {
            CompletableFuture<Void> allFutures = CompletableFuture
            .allOf(completableFutures.toArray(new CompletableFuture[completableFutures.size()]));

            CompletableFuture<List<T>> allCompletableFuture = allFutures.thenApply(
                future -> {
                    System.out.println(String.format("%s <- future", future));
                    return completableFutures.stream()
                        .map(completableFuture -> completableFuture.join())
                        .collect(Collectors.toList());
            });

            return allCompletableFuture;
        }

        public CompletableFuture<List<Test.GreetHolder>> run_tidier() {
            List<String>  langList = Arrays.asList("EN", "ES", "SN"); //, "EX");

            List<CompletableFuture<Test.GreetHolder>> completableFutures =
            langList.stream().map(lang -> getGreeting(lang))
                //.map(CompletableFuture::join);
                .collect(Collectors.toList());
            
            CompletableFuture<List<GreetHolder>> allCompletableFuture = allResultsOf(completableFutures);
            
            System.out.println(String.format("%s <- allCompletableFuture", allCompletableFuture));            
            
            CompletableFuture completableFuture = allCompletableFuture.thenApply(
                greets -> {
                       return greets
                            .stream()
                            .map(GreetHolder::getGreet)
                            .collect(Collectors.toList());
            });
            return completableFuture;
            
            
        }
    }
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService pool = Executors.newFixedThreadPool(2);
        Test t = new Test(pool);
        System.out.println(String.format("%s world!", t.getGreet("EN")));
        CompletableFuture cf = t.run();
        System.out.println(String.format("%s <- cf", cf.get()));
    }
}
-1
lurscher 21 अप्रैल 2021, 15:05
मुझे लगता है कि आपको इसके लिए वाइल्डकार्ड का इस्तेमाल बिल्कुल नहीं करना चाहिए। allOf के लिए जो कुछ भी वायदा लेना है, वह समझ में आता है क्योंकि यह केवल पूरा होने के बारे में है न कि परिणामों के बारे में। जिस क्षण वास्तविक परिणाम प्रासंगिक हो जाते हैं, वाइल्डकार्ड का उपयोग करना स्वाभाविक रूप से गलत हो जाता है। हालाँकि, यह वह समस्या नहीं है जिसके बारे में आप पूछते हैं, बल्कि समस्या इसका एक लक्षण है।
 – 
akuzminykh
21 अप्रैल 2021, 15:18
1
आपके विचार में, रिटर्न में ? और तर्क में ? एक ही प्रकार के हैं। कंपाइलर में वे नहीं हैं। आपको एक प्रकार का वैरिएबल पेश करना होगा जिसका उपयोग आप दोनों जगहों पर कर सकते हैं।
 – 
Matt Timmermans
21 अप्रैल 2021, 15:37
मैंने T या V के साथ प्रयास किया लेकिन मुझे वही कंपाइलर त्रुटि मिलती है। मैंने यह दिखाने के लिए प्रश्न संपादित किया कि यह मामला है
 – 
lurscher
21 अप्रैल 2021, 15:40

1 उत्तर

सबसे बढ़िया उत्तर

जैसा कि मैट टिमरमैन ने सुझाव दिया था, आपको एक प्रकार के चर की आवश्यकता है।

allResultsOf को इस कंपाइल में बदलना:

public static <T> CompletableFuture<List<T>> allResultsOf(List<CompletableFuture<T>> completableFutures) {
            CompletableFuture<Void> allFutures = CompletableFuture
                    .allOf(completableFutures.toArray(new CompletableFuture[completableFutures.size()]));

            CompletableFuture<List<T>> allCompletableFuture = allFutures.thenApply(
                    future -> {
                        System.out.println(String.format("%s <- future", future));
                        return completableFutures.stream()
                                .map(completableFuture -> completableFuture.join())
                                .collect(Collectors.toList());
                    });

            return allCompletableFuture;
        }
1
tgdavies 21 अप्रैल 2021, 15:54
कार्यक्रम को समाप्त करने के लिए अपने मुख्य () परीक्षण विधि के अंत में पूल.शटडाउन () भी जोड़ें
 – 
Daniel Z.
21 अप्रैल 2021, 16:13