किसी भी कारण से अपने निर्धारित कार्यों में से एक बार जावा बंद निष्पादक सेवा

Question

मुझे किसी तरह की सेवा की आवश्यकता है जो कुछ कार्यों को एक साथ और 1 मिनट के लिए 1 सेकंड के अंतराल में चलाएगी।

यदि कोई एक कार्य विफल हो जाता है, तो मैं सेवा को रोकना चाहता हूं और प्रत्येक कार्य जो इसके साथ चलता है, किसी तरह का संकेतक है कि कुछ गलत हो गया है, अन्यथा यदि एक मिनट के बाद सब कुछ ठीक हो जाता है तो सेवा एक संकेतक के साथ बंद हो जाएगी जो सब ठीक हो गया।

उदाहरण के लिए, मेरे 2 कार्य हैं:

Runnable task1 = ()->{
      int num = Math.rand(1,100);
      if (num < 5){
          throw new Exception("something went wrong with this task,terminate");
      }
}

Runnable task2 = ()->{
      int num = Math.rand(1,100)
      return num < 50;
}



ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
task1schedule = scheduledExecutorService.scheduleAtFixedRate(task1, 1, 60, TimeUnit.SECONDS);
task2schedule = scheduledExecutorService.scheduleAtFixedRate(task2, 1, 60, TimeUnit.SECONDS);

if (!task1schedule || !task2schedule) scheduledExecutorService.shutdown();

मुझे इस बारे में कोई विचार करना चाहिए कि मुझे इससे कैसे निपटना चाहिए और चीजों को यथासंभव सामान्य बनाना चाहिए?

Comments

वास्तविक सवाल के अलावा कुछ चीजें, Math.randएक अंतर्निहित एपीआई नहीं है। एक कार्यान्वयन की Runnableएक void runपरिभाषा होनी चाहिए । प्रदान की गई संदर्भ में प्रकार task1/2scheduleहोगा ScheduledFuture<?>। वास्तविक प्रश्न पर चलते हुए, इसका उपयोग कैसे किया जाता है awaitTermination? आप ऐसा कर सकते हैं scheduledExecutorService.awaitTermination(1,TimeUnit.MINUTES);। वैकल्पिक रूप से, अगर किसी भी कार्य को उसके सामान्य पूर्ण होने से पहले रद्द कर दिया गया हो तो जाँच के बारे में if (task1schedule.isCancelled() || task2schedule.isCancelled()) scheduledExecutorService.shutdown();:?

— नमन

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

— होल्गर

Answer 1

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

आप नक्शे "त्रुटियों" और "सफलता" में हर कार्य-पुनरावृत्ति के परिणामों की जांच कर सकते हैं।

public class SchedulerTest {

    @Test
    public void scheduler() throws InterruptedException {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
        TaskCompleteEvent taskCompleteEvent = new TaskCompleteEvent(scheduledExecutorService);
        Runnable task1 = () -> {
            int num = new Random().nextInt(100);
            if (num < 5) {
                taskCompleteEvent.message("task1-"+UUID.randomUUID().toString(), "Num "+num+" was obatined. Breaking all the executions.", true);
            }
        };
        Runnable task2 = () -> {
            int num = new Random().nextInt(100);
            taskCompleteEvent.message("task2-"+UUID.randomUUID().toString(), num < 50, false);
        };
        scheduledExecutorService.scheduleAtFixedRate(task1, 0, 1, TimeUnit.SECONDS);
        scheduledExecutorService.scheduleAtFixedRate(task2, 0, 1, TimeUnit.SECONDS);
        scheduledExecutorService.awaitTermination(60, TimeUnit.SECONDS);
        System.out.println("Success: "+taskCompleteEvent.getSuccess());
        System.out.println("Errors: "+taskCompleteEvent.getErrors());
        System.out.println("Went well?: "+taskCompleteEvent.getErrors().isEmpty());
    }

    public static class TaskCompleteEvent {

        private final ScheduledExecutorService scheduledExecutorService;
        private final Map<String, Object> errors = new LinkedHashMap<>();
        private final Map<String, Object> success = new LinkedHashMap<>();

        public TaskCompleteEvent(ScheduledExecutorService scheduledExecutorService) {
            this.scheduledExecutorService = scheduledExecutorService;
        }

        public synchronized void message(String id, Object response, boolean error) {
            if (error) {
                errors.put(id, response);
                scheduledExecutorService.shutdown();
            } else {
                success.put(id, response);
            }
        }

        public synchronized Map<String, Object> getErrors() {
            return errors;
        }

        public synchronized Map<String, Object> getSuccess() {
            return success;
        }

    }

}

Answer 2

आपको बस एक अतिरिक्त कार्य जोड़ने की आवश्यकता है जिसका काम अन्य सभी चल रहे कार्यों की निगरानी करना है - और जब कोई भी मॉनिटर किए गए कार्य विफल हो जाते हैं, तो उन्हें एक अर्ध-ध्वज (ध्वज) स्थापित करने की आवश्यकता होती है जिसे हत्यारा निरीक्षण कर सकता है।

    ScheduledExecutorService executor = (ScheduledExecutorService) Executors.newScheduledThreadPool(2);

    // INSTANTIATE THE REMOTE-FILE-MONITOR:
    RemoteFileMonitor monitor = new RemoteFileMonitor(remotesource, localtarget);

    // THIS TimerTask PERIODICALLY TRIGGERS THE RemoteFileMonitor: 
    TimerTask remote = new TimerTask() {

        // RUN FORREST... RUN !
        public void run() {

            try { 

                kae.trace("TimerTask::run() --> Calling RemoteFileMonitor.check()");
                monitor.check();

            } catch (Exception ex) {

                // NULL TRAP: ALLOWS US TO CONTINUE AND RETRY:

            }

        }

    };

    // THIS TimerTask PERIODICALLY TRIES TO KILL THE REMOTE-FILE-MONITOR:
    TimerTask assassin = new TimerTask() {

        // WHERE DO BAD FOLKS GO WHEN THEY DIE ? 
        private final LocalDateTime death = LocalDateTime.now().plus(ConfigurationOptions.getPollingCycleTime(), ChronoUnit.MINUTES);

        // RUN FORREST... RUN !
        public void run() {

            // IS THERE LIFE AFTER DEATH ???
            if (LocalDateTime.now().isAfter(death)) {

                // THEY GO TO A LAKE OF FIRE AND FRY:
                kae.error(ReturnCode.MONITOR_POLLING_CYCLE_EXCEEDED);                   

            }

        }

    };

    // SCHEDULE THE PERIODIC EXECUTION OF THE RemoteFileMonitor: (remote --> run() monitor --> check())
    executor.scheduleAtFixedRate(remote, delay, interval, TimeUnit.MINUTES);

    // SCHEDULE PERIODIC ASSASSINATION ATTEMPTS AGAINST THE RemoteFileMonitor: (assassin --> run() --> after death --> die())
    executor.scheduleAtFixedRate(assassin, delay, 60L, TimeUnit.SECONDS);

    // LOOP UNTIL THE MONITOR COMPLETES:
    do {

        try {

            // I THINK I NEED A NAP:
            Thread.sleep(interval * 10);                

        } catch (InterruptedException e) {

            // FAIL && THEN cleanexit();
            kae.error(ReturnCode.MONITORING_ERROR, "Monitoring of the XXXXXX-Ingestion site was interrupted");

        }

        // NOTE: THE MONITOR IS SET TO 'FINISHED' WHEN THE DONE-File IS DELIVERED AND RETRIEVED:
    } while (monitor.isNotFinished());

    // SHUTDOWN THE MONITOR TASK:
    executor.shutdown();

Comments

वर्ग TimerTaskपूरी तरह से असंबंधित है ScheduledExecutorService; यह सिर्फ लागू करने के लिए होता है Runnable। इसके अलावा, समय-समय पर कार्य को निर्धारित करने का कोई मतलब नहीं है, बस यह जांचने के लिए कि क्या किसी विशेष समय ( ConfigurationOptions.getPollingCycleTime()) तक पहुंच गया है। आपके पास एक है ScheduledExecutorService, इसलिए आप इसे वांछित समय के लिए कार्य को सही करने के लिए कह सकते हैं।

— होल्गर

मेरे द्वारा उपयोग किए गए उदाहरण में कार्यान्वयन एक निश्चित समय के बाद एक निष्पादन कार्य को मारना था यदि कार्य पूरा नहीं हुआ था। उपयोग-मामला था: यदि दूरस्थ सर्वर ने 2 घंटे के भीतर फ़ाइल को नहीं गिराया है - कार्य को मारें। यह वही है जो ओपी ने मांगा था।

— ग्रेग पाटनुडे

क्या आपने मेरी टिप्पणी पढ़ी और समझी? इससे कोई फर्क नहीं पड़ता कि कोड क्या करता है, यह बिना किसी कारण के हतोत्साहित वर्ग का उपयोग करता है, बस के TimerTaskसाथ प्रतिस्थापित करता है Runnableऔर आपने समस्या को ठीक कर दिया है, बिना कोड को बदलने के। आगे, बस उपयोग करें executor.schedule(assassin, ConfigurationOptions.getPollingCycleTime(), ChronoUnit.MINUTES);और यह एक बार वांछित समय पर चलेगा, इसलिए, if(LocalDateTime.now().isAfter(death))चेक अप्रचलित है। फिर से, कोड को क्या करता है, इसे बदलने के अलावा, यह बहुत सरल और अधिक कुशल नहीं बदलता है।

— Holger