जावा टाइमर वर्ग: टाइमर कार्य निष्पादित करने के लिए रोक अगर कार्यों में से एक में अपवाद फेंक दिया है

Question

new Timer().scheduleAtFixedRate(new TimerTask() { 
    @Override 
    public void run() { 
     System.out.println("run"); 
     throw new SomeRandomException(); 
    } 
}, 1000, 1000); 

आउटपुट: (अपवाद फेंक दिया जाता है)

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

मैं

new Timer().scheduleAtFixedRate(new TimerTask() { 
    @Override 
    public void run() { 
     try { 
      System.out.println("run"); 
      throw new SomeRandomException(); 
     } catch (Exception e) { 
      System.out.println("dummy catch"); 
     } 
    } 
}, 1000, 1000); 

लेकिन यह लंगड़ा लगता है।

अन्य विकल्प टाइमर क्लास का अपना कार्यान्वयन लिखता है, रन विधि के अपवादों को निगलता है (जो सही नहीं लगता है)।

Answer 1

ScheduledExecutorService का उपयोग करें। यह टाइमर के समान भूमिका निभाता है, लेकिन इसकी कमजोरियों को ठीक करता है (जैसे आप सामना कर रहे हैं)।

Answer 2

ExecutorService; का उपयोग करके आप संकलन समय दोनों को संभाल सकते हैं और अपवाद चला सकते हैं।

Handling exceptions from Java ExecutorService tasks
How is exception handling done in a Callable

ThreadPoolExecutor.java 

final void runWorker(Worker w) { 
    Thread wt = Thread.currentThread(); 
    Runnable task = w.firstTask; 
    w.firstTask = null; 
    w.unlock(); // allow interrupts 
    boolean completedAbruptly = true; 
    try { 
     while (task != null || (task = getTask()) != null) { 
      w.lock(); 
      // If pool is stopping, ensure thread is interrupted; 
      // if not, ensure thread is not interrupted. This 
      // requires a recheck in second case to deal with 
      // shutdownNow race while clearing interrupt 
      if ((runStateAtLeast(ctl.get(), STOP) || 
       (Thread.interrupted() && 
        runStateAtLeast(ctl.get(), STOP))) && 
       !wt.isInterrupted()) 
       wt.interrupt(); 
      try { 
       beforeExecute(wt, task); 
       Throwable thrown = null; 
       try { 
        task.run(); 
       } catch (RuntimeException x) { 
        thrown = x; throw x; 
       } catch (Error x) { 
        thrown = x; throw x; 
       } catch (Throwable x) { 
        thrown = x; throw new Error(x); 
       } finally { 
        afterExecute(task, thrown); 
       } 
      } finally { 
       task = null; 
       w.completedTasks++; 
       w.unlock(); 
      } 
     } 
     completedAbruptly = false; 
    } finally { 
     processWorkerExit(w, completedAbruptly); 
    } 
}