थ्रेड। जावा

Question

में स्लीप विकल्प मुझे बताया गया है कि Thread.Sleep() का उपयोग करना एक खराब समाधान है जब कोई सिंक्रनाइज़ विधि में कार्यों के लूप के भीतर कुछ समय अंतराल बनाना चाहता है।

दूसरी तरफ, मेरे पास दो अलग-अलग धागे हैं जो मेरे प्रोग्राम के चलने वाले समय में सक्रिय हैं और एक साझा ऑब्जेक्ट भी सक्रिय हैं और जब मैं उस साझा ऑब्जेक्ट में ऑब्जेक्ट.वाइट (लम्बा) का उपयोग करता हूं, तो यह मेरे जीयूआई को स्थिर करता है कुछ समय के लिए।

इस समस्या के लिए बेहतर समाधान क्या होगा?

---

अद्यतन कोड का यह हिस्सा धागे जो जीयूआई में शुरू हो रहा है में से एक सहित जाता है:

class temperatureUp extends Thread { @Override public void run() { while(true) { try { GBC.increaseTemp(); updateSystemStatus(); } catch(Exception ex) { StringWriter w = new StringWriter(); ex.printStackTrace(new PrintWriter(w)); txtLog.setText(w + "\n" + txtLog.getText()); } } } };

और इस साझा वस्तु में सिंक्रनाइज़ विधि, जीबीसी है:

public synchronized void increaseTemp() throws InterruptedException{ 
    // don't increase the temperature if the boiler 
    // is not turned on... 
    while (!isBoilerOn) 
     wait(); 

    // increase the current temperature 
    if ((currentTemp + 1) < MAX_TEMP && currentTemp < desiredTemp) { 
     Thread.sleep(2000); ///what should put here if not thread sleep? 
     currentTemp ++;  
     updateGasBoilerStatus(); 
    } 
} 

Answer 1

आप synchronize कथन के दायरे को कम कर सकते हैं। उदाहरण के लिए आप पूरे विधि पर सिंक्रनाइज़ किए जाने

public synchronized void foo() 

आप संशोधक को हटाने और एक तुल्यकालन ब्लॉक बजाय

synchronized (this) { 
    // ... 
} 

का उपयोग करें और इस ब्लॉक की Thread.sleep() बाहर ले जाने के यदि संभव हो सकता है। केवल उन बयानों पर सिंक्रनाइज़ करें जो साझा डेटा के राज्यों को संशोधित करते हैं।

स्विंग के बारे में बहुत सारी थ्रेडिंग समस्याएं Event Dispatcher Thread से संबंधित हैं और इसे आसानी से हल किया जा सकता है। मैं आपको इसे पढ़ने की सलाह देते हैं।

थोड़ा सा पृष्ठभूमि, क्यों आप एक तुल्यकालन ब्लॉक के अंदर Thread.sleep() नहीं बुलाना चाहिए:

स्लीपिंग या जब एक ताला पकड़े इंतजार कर। लॉक के साथ थ्रेड स्लीप कॉलिंग अन्य धागे को समय के लिए प्रगति करने से रोक सकती है और इसलिए संभावित रूप से गंभीर लचीला खतरे है। कॉलिंग ऑब्जेक्ट.वेट या कंडीशन.एइट दो लॉक के साथ एक समान खतरे का निर्माण करता है। [JCIP]

Answer 2

सिंक्रनाइज़ विधि के अंदर सोएं मत! जीयूआई घटना हैंडलर/तरीकों में इंतजार मत करो!

सिंक्रनाइज़ किए गए कार्यों को विभाजित करें ताकि नींद() कॉल को GUI थ्रेड संदर्भ में नहीं कहा जा सके।

शायद दूसरे बिट के लिए InvokeLater() का उपयोग करें।

Answer 3

मैं मॉनीटर का उपयोग करता हूं: http://www.artima.com/insidejvm/ed2/threadsynch4.html शायद सूचित या अधिसूचित करने के साथ आप इसे हल कर सकते हैं। सौभाग्य!

Answer 4

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

synchronized(this){ 
    //... 
} 

Answer 5

आप इस निम्नलिखित कोड की कोशिश कर सकते सिंक्रनाइज़: देरी के रूप में

public static void delay(int waitTime) { 
     long endTime = System.currentTimeMillis() + (waitTime * 1000); 
     while (System.currentTimeMillis() < endTime) {} 
    } 

कॉल (5)। और नियंत्रण 5 सेकंड तक इंतजार करेगा।