ThreadPoolExecutor में सभी श्रमिकों को तुरंत समाप्त करने के लिए कैसे करें

Question

मेरे पास TheadPoolExecutor के अंदर कई कार्य हैं। मेरे इंटरफ़ेस पर एक स्टॉप बटन है जो तुरंत ThreadPoolExecutor के अंदर सभी थ्रेड को समाप्त कर देना चाहिए। मैं इसे करने का एक तरीका ढूंढ रहा हूं। (shutDown() या shutDownNow() के बिना)।

धन्यवाद

Answer 1

आप तुरंत थ्रेड को सुरक्षित रूप से मार नहीं सकते हैं। इसके बजाय कार्यों को बाधाओं का सम्मान करना चाहिए और बाधित होने पर रोकना चाहिए। यदि आप ThreadPoolExecutor.shutdownNow() का उपयोग करते हैं, तो सभी चल रहे कार्यों में बाधा आ जाएगी।

एक अलग प्रक्रिया में धागे का एकमात्र विकल्प प्रक्रिया को मारने के लिए संकेत जारी करना है।

Answer 2

shutdown() केवल ThreadPoolExecutor सभी नए सबमिट किए कार्यों को अस्वीकार करने के बनाने के लिए, और कतार (यदि ThreadPool एक असीम कतार निष्पादक है) लंबित कार्य से हट जाएँगे। shutdownNow() बिल्कुल वही करेगा, और Thread की interrupt() विधि पर भी कॉल करेगा। तो, अपने run() विधि में, आप इसे ठीक से संभाल चाहिए:

try { 
    Thread.sleep(1000); 
} catch (InterruptedException ie) { 
    // Handle the exception, and close resources. 
} 

Answer 3

आप अपने धागे में Runnable रों बजाय Callable रों उपयोग कर सकते हैं आप की कोशिश कर सकते हैं और someTask.cancel() को कॉल करते हैं के समय में चल रहे कार्यों से छुटकारा पाने के shutdownNow() कॉल करें।

ध्यान दें कि मैंने यह कोशिश नहीं की है, इसलिए मैं गारंटी नहीं दे सकता कि यह आपके जैसा काम करेगा, लेकिन जावाडोक विवरण से निर्णय लेना एक कोशिश के लायक है।

Answer 4

पुराना सवाल है लेकिन मुझे लगता है कि आप पहले से निष्पादन() में चल रहे थ्रेड संदर्भ को कैप्चर करने के लिए ThreadPoolExecutor का विस्तार कर सकते हैं। जब shutdownNow() कहा जाएगा तो आप सभी चल रहे थ्रेड को रोक सकते हैं। हालांकि मैं आपके कार्यों में अंतर्निहित() पर भरोसा करने के लिए दृढ़ता से प्रोत्साहित करता हूं।

नमूना कोड ->

public class KillableThreadPoolExecutor extends ThreadPoolExecutor { 

    private final Map<Runnable, Thread> executingThreads; 

    public KillableThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, String threadNamePrefix) { 
     super(corePoolSize, maximumPoolSize, keepAliveTime, unit, new YoungMemorySafeLinkedBlockingQueue<Runnable>(), ThreadFactories.create(threadNamePrefix)); 
     executingThreads = new HashMap<>(maximumPoolSize); 
    } 

    @Override 
    protected synchronized void beforeExecute(Thread t, Runnable r) { 
     super.beforeExecute(t, r); 
     executingThreads.put(r, t); 
    } 

    @Override 
    protected synchronized void afterExecute(Runnable r, Throwable t) { 
     super.afterExecute(r, t); 
     if(executingThreads.containsKey(r)) { 
      executingThreads.remove(r); 
     } 
    } 

    @Override 
    public synchronized List<Runnable> shutdownNow() { 
     List<Runnable> runnables = super.shutdownNow(); 
     for(Thread t : executingThreads.values()) { 
      t.stop(); 
     } 
     return runnables; 
    } 
} 

Answer 5

ThreadPoolExecutor एक ExecutorService है। आप ExecutorService में shutdown() या shutdownNow() विधियों के साथ सभी धागे को रोक नहीं सकते हैं। सभी के लिए सभी Future.get() के माध्यम से

1. invokeAll()
2. CountDownLatch
3. दोहराएं: आप के रूप में ओरेकल प्रलेखन द्वारा उद्धृत page

   void shutdownAndAwaitTermination(ExecutorService pool) { 
       pool.shutdown(); // Disable new tasks from being submitted 
       try { 
       // Wait a while for existing tasks to terminate 
       if (!pool.awaitTermination(60, TimeUnit.SECONDS)) { 
        pool.shutdownNow(); // Cancel currently executing tasks 
        // Wait a while for tasks to respond to being cancelled 
        if (!pool.awaitTermination(60, TimeUnit.SECONDS)) 
         System.err.println("Pool did not terminate"); 
       } 
       } catch (InterruptedException ie) { 
       // (Re-)Cancel if current thread also interrupted 
       pool.shutdownNow(); 
       // Preserve interrupt status 
       Thread.currentThread().interrupt(); 
       } 
   } 
   

   अन्य विकल्प सुंदर शटडाउन के लिए एक दृश्य में shutdown(), awaitTermination() और shutdownNow() तरीकों कॉल करनी होगी Callable कार्य एक ही उद्देश्य को प्राप्त करने के लिए।