जावा थ्रेड को शानदार तरीके से कैसे रोकें?

Question

मैंने एक धागा लिखा, इसे निष्पादित करने में बहुत अधिक समय लग रहा है और ऐसा लगता है कि यह पूरी तरह से नहीं किया जाता है। मैं धागे को गहराई से रोकना चाहता हूं। कोई मदद ?

Answer 1

अच्छा जिस तरह से यह धागा एक boolean चर द्वारा सुरक्षित की run() की तरह कुछ है और बाहर से true के लिए सेट जब आप इसे बंद करना चाहते हैं, है क्या करने के लिए:

class MyThread extends Thread 
{ 
    volatile boolean finished = false; 

    public void stopMe() 
    { 
    finished = true; 
    } 

    public void run() 
    { 
    while (!finished) 
    { 
     //do dirty work 
    } 
    } 
} 

एक बार एक समय पर stop() विधि मौजूद थी, लेकिन प्रलेखन के अनुसार

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

है यही कारण है कि आप एक गार्ड होना चाहिए ..

Answer 2

कहीं अस्थिर बूलियन stop बनाएं। तो कोड है कि सूत्र में चलाता है, नियमित रूप से

if (stop) // end gracefully by breaking out of loop or whatever 

कर धागा रोकने के लिए, true को stop निर्धारित किया है।

मुझे लगता है कि आपको इसे मैन्युअल रूप से करना होगा। आखिरकार, धागे में चलने वाले कोड में कोई विचार नहीं है कि क्या है और क्या सुंदर नहीं है।

Answer 3

आप अन्य एक से धागा मार नहीं करना चाहिए। इसे काफी बुरी आदत माना जाता है। हालांकि, कई तरीके हैं। आप थ्रेड की run विधि से return कथन का उपयोग कर सकते हैं। या आप जांच सकते हैं कि थ्रेड पहले से ही बाधित हो चुका है और फिर यह उसका काम रद्द कर देगा। उदा :

while (!isInterrupted()) { 
    // doStuff 
} 

Answer 4

आपको थ्रेड को स्टॉप-संदेश भेजने की आवश्यकता है और थ्रेड को संदेश प्राप्त होने पर स्वयं को कार्रवाई करने की आवश्यकता है। यह बहुत आसान है अगर लंबे समय से चल कार्रवाई पाश अंदर है:

public class StoppableThread extends Thread { 

    private volatile boolean stop = false; 

    public void stopGracefully() { 
    stop = true; 
    } 

    public void run() { 
    boolean finished = false; 
    while (!stop && !finished) { 
     // long running action - finished will be true once work is done 
    } 
    } 
} 

Answer 5

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

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

आप थ्रेड की रन विधि लिख सकते हैं ताकि इंटरप्टेड एक्सेप्शन थ्रेड कर रहे लूपिंग लॉजिक के बाहर पकड़ा जा सके, या आप लूप के भीतर अपवाद को पकड़ सकते हैं और अपवाद फेंकने वाले कॉल के करीब, इंटरप्ट फ्लैग को अंदर रख सकते हैं InterruptedException के लिए ब्लॉक को पकड़ें ताकि थ्रेड इस तथ्य का ट्रैक न खो सके कि यह बाधित था। बाधित थ्रेड अभी भी नियंत्रण रख सकता है और अपनी शर्तों पर प्रसंस्करण समाप्त कर सकता है।

मैं एक कार्यकर्ता धागा है कि वेतन वृद्धि, जहां किसी कारण से बीच में एक नींद वहाँ में काम करता है लिखना चाहते कहो, और मैं नींद छोड़ने प्रसंस्करण बनाने के लिए नहीं करना चाहती है कि वेतन वृद्धि के लिए शेष काम कर रही बिना छोड़ दी , मैं सिर्फ यह छोड़ना चाहते अगर यह के बीच वेतन वृद्धि है:

class MyThread extends Thread 
{ 
    public void run() 
    { 
     while (!Thread.currentThread().isInterrupted()) 
     { 
      doFirstPartOfIncrement(); 
      try { 
       Thread.sleep(10000L); 
      } catch (InterruptedException e) { 
       // restore interrupt flag 
       Thread.currentThread().interrupt(); 
      } 
      doSecondPartOfIncrement(); 
     } 
    } 
} 

Here is an answer to a similar question, including example code.

Answer 6

एक धागा ही रोकने के लिए के लिए, कोई भी उल्लेख किया है लगता है (गलत) अपवाद का उपयोग कर:

abstract class SelfStoppingThread extends Thread { 

    @Override 
    public final void run() { 
     try { 
      doRun(); 
     } catch (final Stop stop) { 
      //optional logging 
     } 
    } 

    abstract void doRun(); 

    protected final void stopSelf() { 
     throw new Stop(); 
    } 

    private static final class Stop extends RuntimeException {}; 

} 

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