निम्नलिखित कोड में इरादा एक कार्य के अतुल्यकालिक निष्पादन को प्राप्त करना है, बशर्ते यह 100 एमएस से कम में चलता है और अन्य थ्रेड से टाइमआउट अपवाद फेंक दिया जाएगा,

प्रश्न : उस थ्रेड का क्या होता है जो 100 ms से अधिक के लिए अतुल्यकालिक रूप से क्रियान्वित हो रहा है, क्या इसे जारी किया जाएगा? या यह अपवाद को फेंके बिना कार्य के पूरा होने की प्रतीक्षा करेगा? (कोड को यह सोचकर लिखा है कि स्वीकार करें या तो लंबे समय तक चलने वाले कार्य को समाप्त कर देगा जब यह दूसरे भविष्य से टाइमऑट अपवाद का सामना करेगा)

private static final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
    public static <T> CompletableFuture<T> failAfter(long longValue) {
        final CompletableFuture<T> timeoutFuture = new CompletableFuture<>();
        scheduler.schedule(() -> {
            final TimeoutException ex = new TimeoutException("Timing out");
            return timeoutFuture.completeExceptionally(ex);
        }, longValue, TimeUnit.MILLISECONDS);
        return timeoutFuture;
    }  

final CompletableFuture<CustomResponse> CustomResponseFuture = CompletableFuture.supplyAsync(() -> object.taks()).
                exceptionally(ex -> {
                    System.out.println("help");
                    return new "Hello";
                    });

        CustomResponseFuture
        .acceptEither(failAfter(100l), TesFutureStuff::myNewMethod)
        .exceptionally(throwable -> {
            System.out.println("failure "+throwable.getMessage());
             return null;
        })/*.getNow(null )*/;
0
Mozhi 27 जुलाई 2018, 20:30
एक ऐसा कार्य बनाना जो समय समाप्त हो सके, इस सारी जटिलता की आवश्यकता नहीं है। बस एक एक्ज़ीक्यूटर सर्विस बनाएं, और इसके invokeAny विधि।
 – 
VGR
27 जुलाई 2018, 20:42
धन्यवाद, क्या आप कृपया मुझे बता सकते हैं कि मैं कैसे प्राप्त कर सकता हूं कि पूर्ण भविष्य का उपयोग करके, जावा 8 शब्दकोष का उपयोग करके इसे आजमा देना चाहता हूं
 – 
Mozhi
27 जुलाई 2018, 20:53

2 जवाब

यदि आप केवल एक ऐसा कार्य चाहते हैं जो एक विशिष्ट समय के बाद समाप्त हो जाए, तो आपको CompletableFuture की आवश्यकता नहीं है। बस एक्ज़ीक्यूटर सर्विस बनाएं a>, और इसके invokeAny विधि।

यदि आप CompletableFuture का उपयोग करने पर जोर देते हैं, तो आप इसके प्राप्त करें और रद्द करें तरीके:

CompletableFuture<CustomResponse> future = CompletableFuture.supplyAsync(() -> object.task());
try {
    CustomResponse response = future.get(100, TimeUnit.MILLISECONDS);
    // process response here
} catch (ExecutionException e) {
    throw new RuntimeException(e);
} catch (TimeoutException e) {
    System.out.println(e);
    future.cancel(true);
}

अपडेट करें:

पृष्ठभूमि में पूरी चीज करने के लिए, उसी एक्जिक्यूटर सर्विस को इनवोकएनी कॉल सबमिट करें, लेकिन सुनिश्चित करें कि एक्जिक्यूटर सर्विस सिंगल थ्रेडेड नहीं है। कई विकल्प हैं: Executors.newFixedThreadPool(2), Executors.newWorkStealingPool(), Executors.newCachedThreadPool, या यहां तक ​​कि ForkJoinPool.commonPool()

CompletableFuture दृष्टिकोण के लिए, मैंने अभी देखा है कि Java 9 के रूप में, CompletableFuture एक या Timeout विधि:

future.orTimeout(100, TimeUnit.MILLISECONDS);
2
VGR 30 जुलाई 2018, 00:13
लेकिन प्राप्त करने के लिए कॉल() सही अवरुद्ध कर रहा है, इसलिए मेरा पूरा दृष्टिकोण वास्तव में इससे बचना है।
 – 
Mozhi
28 जुलाई 2018, 06:10
अद्यतन उत्तर। मुझे एहसास नहीं हुआ था कि जब जावा 9 जारी किया गया था, तो कंप्लीटेबल फ्यूचर में कई नए तरीके जोड़े गए थे ...
 – 
VGR
30 जुलाई 2018, 00:14
CompletableFuture.supplyAsync(() -> execute(task), executorService)  
                 .acceptEither(new CompletableFuture()
                 .completeExceptionally( new RuntimeException(String.format("timed out %d %s",timeout, unit.name()))), result ->onSuccess(task,result))
                 .exceptionally(throwable -> onError(task));
-1
Mohamed Ismail M 23 अगस्त 2019, 12:36