जेवीएम डिमन थ्रेड को कैसे समाप्त करता है? या डेमॉन थ्रेड कैसे लिखें जो

Question

हाइपोटेटिकल परिदृश्य:
मेरे पास कुछ I/O, मुख्य थ्रेड खत्म और रिटर्न के लिए जिम्मेदार एक डिमन थ्रेड है, और JVM मेरे डिमन थ्रेड को समाप्त करने का निर्णय लेता है।

ऐसा कैसे करता है? बीच में? अंतिम रूप? मैं अपने डेमॉन थ्रेड को कैसे कोड कर सकता हूं ताकि जब इसे समाप्त किया जाए तो यह शानदार ढंग से प्रतिक्रिया करता है?

Answer 1

मैं सिर्फ एक परीक्षण के रूप में निम्नलिखित कोड लिखा है:

public class DaemonThreadPlay { 
    public static void main(String [] args) { 
     Thread daemonThread = new Thread() { 
      public void run() { 
       while (true) { 
        try { 
         System.out.println("Try block executed"); 
         Thread.sleep(1000l); 
        } catch (Throwable t) { 
         t.printStackTrace(); 
        } 
       } 
      } 

      @Override 
      public void finalize() { 
       System.out.println("Finalize method called"); 
      } 
     }; 
     daemonThread.setDaemon(true); 
     daemonThread.start(); 

     try { 
      Thread.sleep(2500l); 
     } catch (Throwable t) { 
      //NO-OP 
     } 
    } 
}  

मैं डेमॉन धागे की पकड़ ब्लॉक में और अंतिम रूप देने विधि में breakpoints डाल दिया। कोशिश ब्लॉक को निष्पादित किए जाने के बावजूद ब्रेकपॉइंट तक पहुंचा नहीं गया था। जाहिर है इस कोड में सिंक्रनाइज़ेशन/टाइमिंग समस्याएं हैं, लेकिन मुझे लगता है कि हम सुरक्षित रूप से निष्कर्ष निकाल सकते हैं कि शटडाउन पर डिमन थ्रेड बाधित नहीं होते हैं और न ही उनके अंतिम() विधियों को जरूरी रूप से लागू किया जाता है।

तुम हमेशा JVM रनटाइम करने के लिए एक बंद हुक जोड़ सकते हैं:

Thread shutdownHook = ... // construct thread that somehow 
          // knows about all the daemon threads 
Runtime.getRuntime().addShutdownHook(shutdownHook); 

आपका बंद हुक स्पष्ट रूप से जो कुछ भी कार्य एक "सुंदर" शट डाउन के लिए आवश्यक हैं कर सकते हैं।

Answer 2

AFAIK, डेमॉन धागे मुख्य धारा I/O काम के लिए वास्तव में नहीं हैं। यदि सभी धागे पूरे हो गए हैं, तो JVM अचानक सभी डिमन थ्रेड बंद कर सकता है। शटडाउन हुक से

ExecutorService execPool = Executors.newSingleThreadExecutor(new ThreadFactory() { 

    @Override  
    public Thread newThread(Runnable runnable) {  
     Thread thread = Executors.defaultThreadFactory().newThread(runnable); 
     thread.setDaemon(true); 
     return thread;  
    } 
}); 

आह्वान executorservice बंद विधि: आपकी आवश्यकता के लिए चारों ओर संभव काम नीचे की तरह एक ExecutorService बनाने होगा।

Runtime.getRuntime().addShutdownHook(....) 

Answer 3

उपयोग बाधा और शामिल होने:

class Daemon extends Thread { 
    public void run() { 
     while (true) { 
      try { 
       Thread.sleep(1000); 
      } catch (InterruptedException e) { 
       System.out.println(e); 
       break; 
      } 
     } 
     System.out.println("exit run()"); 
    } 
} 
public class So8663107 { 
    public static void main(String[] arguments) throws InterruptedException { 
     System.out.println(Thread.activeCount()); 
     Daemon daemon = new Daemon(); 
     daemon.setDaemon(true); 
     daemon.start(); 
     Thread.sleep(2500); 
     System.out.println(Thread.activeCount()); 
     daemon.interrupt(); 
     daemon.join(); 
     System.out.println(Thread.activeCount()); 
    } 
} 

Answer 4

मुझे लगता है कि आप गलत क्या एक डेमॉन धागा है।

देखें what is a daemon thread in java

सारांश में, यह मूल रूप से मतलब है कि एक डेमॉन धागा किसी भी आई/ओ कर नहीं किया जाना चाहिए या किसी संसाधनों पकड़े। यदि आप इस मूल नियम का उल्लंघन कर रहे हैं तो आपका धागा डेमॉन थ्रेड होने योग्य नहीं है।

शटडाउन हुक जोड़ना आपके कोड को JVM समाप्ति से पहले सुनिश्चित करने का मानक तरीका है, लेकिन यह 100% गारंटी नहीं है - आपका जेवीएम उदाहरण के लिए क्रैश हो सकता है, जिससे ओएस को संसाधनों को व्यवस्थित करने के लिए छोड़ दिया जा सकता है जो ओएस की रक्षा करता है, लेकिन संभवतः आपके आवेदन को असंगत/गलत स्थिति में छोड़ देता है।

सिस्टम चेकपॉइंटिंग और रिकवरी तंत्र सॉफ़्टवेयर के प्रारंभिक दिनों (उदाहरण के लिए ऑपरेटिंग सिस्टम और बैच ऑपरेशंस) पर वापस जाते हैं, और दुर्भाग्यवश, यह पहिया फिर से आविष्कार कर रहा है क्योंकि कोई "चांदी बुलेट" दृष्टिकोण (एपीआई) नहीं है जो tackles एक सामान्य पर्याप्त तरीके से यह समस्या।