एक ExecutorService टर्निंग जावा

Question

में डेमॉन को

मैं जावा 1.6 में एक ExecutoreService उपयोग कर रहा हूँ,

ExecutorService pool = Executors.newFixedThreadPool(THREADS). 

जब मेरे मुख्य थ्रेड (सभी कार्य थ्रेड पूल द्वारा कार्रवाई के साथ) समाप्त हो गया है, इस पूल से बस शुरू कर दिया मैं जब तक नीचे बंद से मेरा कार्यक्रम नहीं कर पाएगा स्पष्ट रूप से कहते हैं

pool.shutdown(); 

मैं किसी भी तरह आंतरिक धागा मोड़ एक deamon धागा में इस पूल द्वारा प्रयोग किया जाता के प्रबंधन के द्वारा इस कॉल करने के लिए होने से बच सकते हैं? या मुझसे यहां कुछ छूट रहा है।

Answer 1

शायद सबसे सरल और पसंदीदा समाधान Marco13's answer में है इसलिए मतभेद मत बनो (मेरा जवाब कुछ साल पुराना है) या स्वीकृति चिह्न (इसका मतलब यह है कि मेरा समाधान ओपी परिस्थितियों के लिए उपयुक्त था कि यह सर्वोत्तम नहीं है) ।

---

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

ExecutorService exec = Executors.newFixedThreadPool(4, 
     new ThreadFactory() { 
      public Thread newThread(Runnable r) { 
       Thread t = Executors.defaultThreadFactory().newThread(r); 
       t.setDaemon(true); 
       return t; 
      } 
     }); 

exec.execute(YourTaskNowWillBeDaemon); 

---

लेकिन आप निष्पादक जो अपने कार्य को खत्म करने देगा, और एक ही समय में स्वचालित रूप से अपने shutdown() विधि कॉल होगा जब आवेदन पूरा हो गया है प्राप्त करना चाहते हैं, तो आप रैप करने के लिए चाहते हो सकता है: यहाँ सरल उदाहरण है Guava'sMoreExecutors.getExitingExecutorService के साथ आपका निष्पादक।

ExecutorService exec = MoreExecutors.getExitingExecutorService(
     (ThreadPoolExecutor) Executors.newFixedThreadPool(4), 
     100_000, TimeUnit.DAYS//period after which executor will be automatically closed 
          //I assume that 100_000 days is enough to simulate infinity 
); 
//exec.execute(YourTask); 
exec.execute(() -> { 
    for (int i = 0; i < 3; i++) { 
     System.out.println("daemon"); 
     try { 
      TimeUnit.SECONDS.sleep(1); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
    } 
}); 

Answer 2

हां।

आपको बस अपना खुद का ThreadFactory कक्षा बनाने की आवश्यकता है जो नियमित धागे की बजाय डेमॉन थ्रेड बनाता है।

Answer 3

वहां पहले से ही है एक ExecutorService कि निष्क्रियता की एक निश्चित अवधि के बाद सभी थ्रेड समाप्त हो जाता है बनाने के लिए एक में निर्मित कार्यक्षमता: आप एक ThreadPoolExecutor बनाने के लिए, यह वांछित समय जानकारी पारित कर सकते हैं, और फिर इस निष्पादक पर allowCoreThreadTimeout(true) फोन सेवा:

/** 
* Creates an executor service with a fixed pool size, that will time 
* out after a certain period of inactivity. 
* 
* @param poolSize The core- and maximum pool size 
* @param keepAliveTime The keep alive time 
* @param timeUnit The time unit 
* @return The executor service 
*/ 
public static ExecutorService createFixedTimeoutExecutorService(
    int poolSize, long keepAliveTime, TimeUnit timeUnit) 
{ 
    ThreadPoolExecutor e = 
     new ThreadPoolExecutor(poolSize, poolSize, 
      keepAliveTime, timeUnit, new LinkedBlockingQueue<Runnable>()); 
    e.allowCoreThreadTimeOut(true); 
    return e; 
} 

संपादित टिप्पणियों में की गयी टिप्पणी का जिक्र करते हुए: ध्यान दें कि यह थ्रेड पूल निष्पादक स्वचालित रूप से आवेदन बाहर निकलता है बंद नहीं होगा। एप्लिकेशन बाहर निकलने के बाद निष्पादक जारी रहेगा, लेकिन keepAliveTime से अधिक नहीं है। यदि, सटीक आवेदन आवश्यकताओं के आधार पर, keepAliveTime को कुछ सेकंड से अधिक समय तक होना चाहिए, answer by Pshemo में समाधान अधिक उपयुक्त हो सकता है: जब थ्रेड डिमन थ्रेड के रूप में सेट होते हैं, तो जब एप्लिकेशन निकलता है तो वे तत्काल समाप्त हो जाएंगे।

Answer 4

मैं गुवा के थ्रेडफैक्टरीबिल्डर वर्ग का उपयोग करूंगा।

ExecutorService threadPool = Executors.newFixedThreadPool(THREADS, new ThreadFactoryBuilder().setDaemon(true).build()); 

आप पहले से ही अमरूद उपयोग नहीं कर रहे हैं, मैं Pshemo's answer

Answer 5

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

जब आपका मुख्य धागा पूरा हो जाता है, तो सबमिट किए गए कार्यों को पूरा करने के लिए समय की अनुमति देने के लिए awaitTermination() विधि का उपयोग करें। वर्तमान में सबमिट किए गए कार्यों को निष्पादित किया जाएगा, और थ्रेड पूल पूरा होने के बाद अपने नियंत्रण धागे को समाप्त कर देगा।

for (Runnable task : tasks) { 
    threadPool.submit(task); 
} 
threadPool.shutdown(); 
/*... do other stuff ...*/ 
//All done, ready to exit 
while (!threadPool.isTerminated()) { 
    //this can throw InterruptedException, you'll need to decide how to deal with that. 
    threadPool.awaitTermination(1,TimeUnit.SECOND); 
}