जावा में जेएफआरएएम को बंद करने के लिए मैं थ्रेड इंतजार कैसे करूं?

Question

जब प्रोग्राम शुरू होता है, तो एक नया जेएफआरम बनाया जाता है। एक बार जब उपयोगकर्ता स्टार्ट बटन पर क्लिक करता है तो थ्रेड बनाया जाता है और शुरू होता है। इस थ्रेड निष्पादन का हिस्सा फ़ॉर्म पर डेटा को सत्यापित करना है और फिर उस डेटा के साथ निष्पादित करना है। एक बार डेटा को मान्य कर दिया गया है, थ्रेड कॉल मूल फ्रेम पर() को निपटान करते हैं और फिर एक नया जेएफआरएम बनाता है जो नियंत्रण कक्ष के रूप में कार्य करता है।

प्रोग्राम का एक स्वचालित मोड भी है जो किसी भी जीयूआई को प्रदर्शित नहीं करता है, यह मोड कॉन्फ़िगरेशन फ़ाइल से डेटा पढ़ता है और फिर निष्पादन थ्रेड शुरू करता है और नियंत्रण कक्ष के बिना सब कुछ चलाता है।

मैं चाहता हूं कि थ्रेड पूरा होने के बाद प्रोग्राम समाप्त हो जाए, लेकिन जीयूआई मोड में, केवल तभी उपयोगकर्ता ने नियंत्रण कक्ष बंद कर दिया हो। फ्रेम को बंद करने के लिए थ्रेड को प्रतीक्षा करना संभव है। मुझे लगता है कि फ्रेम अपने स्वयं के धागे से चलाया जाता है? या यह मामला नहीं है।

धन्यवाद।

Answer 1

आपके द्वारा चुना गया उत्तर थोड़ा अजीब है। Thread.sleep (1000) का उपयोग हर दूसरे विंडो विंडो की जांच करेगा। यह एक प्रदर्शन मुद्दा नहीं है, बल्कि खराब कोडिंग शैली है। और आपके पास एक दूसरा प्रतिक्रिया समय हो सकता है।

यह कोड थोड़ा बेहतर है।

private static Object lock = new Object(); 
private static JFrame frame = new JFrame(); 
/** 
* @param args 
*/ 
public static void main(String[] args) { 

    frame.setSize(300, 300); 
    frame.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE); 
    frame.setVisible(true); 

    Thread t = new Thread() { 
     public void run() { 
      synchronized(lock) { 
       while (frame.isVisible()) 
        try { 
         lock.wait(); 
        } catch (InterruptedException e) { 
         e.printStackTrace(); 
        } 
       System.out.println("Working now"); 
      } 
     } 
    }; 
    t.start(); 

    frame.addWindowListener(new WindowAdapter() { 

     @Override 
     public void windowClosing(WindowEvent arg0) { 
      synchronized (lock) { 
       frame.setVisible(false); 
       lock.notify(); 
      } 
     } 

    }); 

    t.join(); 
} 

Answer 2

आप अपने धागे से जेएफआरएएम में संदर्भ दे सकते हैं। फिर JFrame का डिफ़ॉल्ट बंद संचालन HIDE_ON_CLOSE पर सेट करें। यदि जेएफआरएम बंद है, तो आप धागे को रोक सकते हैं।

उदाहरण कोड: JFrame सहित

import java.awt.Dimension; 

import javax.swing.JFrame; 

public class FrameExample extends JFrame { 

    public FrameExample() { 
     setSize(new Dimension(100, 100)); 
     setDefaultCloseOperation(HIDE_ON_CLOSE); 
     setVisible(true); 

    } 

    private static class T implements Runnable { 

     private FrameExample e; 

    public T(FrameExample e) { 
     this.e = e; 
    } 

    @Override 
    public void run() { 
     while (true) { 
      if (e.isVisible()) { 
       // do the validation 
       System.out.println("validation"); 
       try { 
        Thread.sleep(1000); 
       } catch (InterruptedException e1) { 
        break; 
       } 
      } 
     } 
    } 

} 

public static void main(String[] args) { 
    FrameExample frameExample = new FrameExample(); 

    new Thread(new T(frameExample)).start(); 
    } 
} 

Answer 3

सभी घुमाओ घटकों, किसी एकल थ्रेड द्वारा प्रबंधित कर रहे हैं, घटना डिस्पैच थ्रेड, या EDT कहा जाता है। (अन्य धागे से स्विंग ऑब्जेक्ट्स पर विधियों को कॉल करना संभव है, लेकिन यह आमतौर पर असुरक्षित है, कुछ मामलों को छोड़कर यहां प्रासंगिक नहीं है।)

आप शायद डेटा सत्यापन और निष्पादन कोड डालकर जो चाहते हैं उसे पूरा करेंगे अपनी खुद की वस्तु में जो अन्यथा बाहरी दुनिया से पूरी तरह से अनजान है। फिर, इसे दो अन्य वस्तुओं में से एक से कॉल करें: वह जो एक जीयूआई प्रबंधित करता है, और दूसरा जो "स्वचालित मोड" में चलता है।