Automatisches schliessen eines Dialogs

[Kaladial]

moin

also ich hab da nen problem und ma nen kleines programm geschireben was das verdeutlichen soll...
unten also der quellcode...

beschreibung meines problems:

also ich starte eine komunikation mit einer com-schnittstelle schick der nen befehl und danach muss ich die com schliesen und mit anderen parametern wieder öffnen ...

nun will ich aber warten bis die com auch geschlossen ist bis ich eine neue aufmachen will

also:

1.) aufmachen
2.) befehl senden
3.) schliessen
4.) warten bis geschlossen ist
5.) neu aufmachen

punkt 1-3 und 5 sind kein problem

nr 4 schon ...

also zu meinem programm:
ich hab ne frunktion die einen thread startet in dem die komunikation mit der com abläuft
und wenn ich nun der com sage schliess dich ´wird zum schluss jeder thead gekillt und danach eine variable stop gesetzt... in meinem restlichen programm soll ein dialog aufgehn wo drin steht: noch in arbeit

und wenn der thread die variable stop auf true setzt soll sich der dialog automatisch schliessen und mein programm soll weiter machen und die richtige komunikation starten ...

was geht bisher:

also com starten und stopen klappen / variable setzten auch kein problem...
dialog aufmachen auch nicht ...

was geht nicht:

dialog schliesen ...


also hier mal der code...
und ich hioffe ich hab mich verständlich ausgedrückt

package testapp;

import javax.swing.SwingUtilities;
import java.awt.BorderLayout;
import java.awt.Rectangle;

import javax.swing.JPanel;
import javax.swing.JFrame;
import javax.swing.JButton;

public class CloseDLG extends JFrame {

	private static final long serialVersionUID = 1L;
	private JPanel jContentPane = null;
	public static CloseDLGThread clt;  //  @jve:decl-index=0:
	private JButton jButton = null;
	/**
	 * This method initializes jButton	
	 * 	
	 * @return javax.swing.JButton	
	 */

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		SwingUtilities.invokeLater(new Runnable() {
			public void run() {
				CloseDLG thisClass = new CloseDLG();
				thisClass.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
				thisClass.setVisible(true);
			}
		});
	}

	/**
	 * This is the default constructor
	 */
	public CloseDLG() {
		super();
		initialize();
	}

	/**
	 * This method initializes this
	 * 
	 * @return void
	 */
	private void initialize() {
		this.setSize(600, 400);
		this.setContentPane(getJContentPane());
		this.setTitle("JFrame");
		
	}

	/**
	 * This method initializes jContentPane
	 * 
	 * @return javax.swing.JPanel
	 */
	private JPanel getJContentPane() {
		if (jContentPane == null) {
			jContentPane = new JPanel();
			jContentPane.setLayout(null);
			jContentPane.add(getJButton(), null);

		}

		return jContentPane;
	}
	
	private JButton getJButton() {
		if (jButton == null) {
			jButton = new JButton();
			jButton.setText("go");
			jButton.setBounds(new Rectangle(150, 50, 150, 20));
			jButton.addActionListener(new java.awt.event.ActionListener() {
				public void actionPerformed(java.awt.event.ActionEvent e) {
					clt = new CloseDLGThread();
					clt.start();
					go();
				}
			});
		}
		return jButton;
	}

	public void go(){
		CloseDLGDialog dlg = new CloseDLGDialog(this, "Starte Com-Port-Verbindung"); 
		dlg.setTitle("Starte Com-Port-Verbindung");
		dlg.setModal(true);
		dlg.setVisible(true);
	}
}

package testapp;

public class CloseDLGThread extends Thread {
	boolean running=false;
	public boolean stop=false;
	
	public CloseDLGThread() {
	}

	public void stopThread(){
		running=false;
	}
	
	public void run() { 
		try { 
			while (true) {
				while (running) {
					try {
						sleep(10000L);
						stop=true;
					} catch (Exception e){}
				} 
			}
		} catch (Exception e){System.out.println("MT1:"+e);}
	}

}

package testapp;

import javax.swing.JLabel;
import javax.swing.JPanel;
import java.awt.Frame;
import java.awt.BorderLayout;
import java.awt.Rectangle;

import javax.swing.JDialog;

public class CloseDLGDialog extends JDialog {

	private static final long serialVersionUID = 1L;
	private JPanel jContentPane = null;
	private JLabel jLabelMeldung = null;
	String meldung="";

	/**
	 * @param owner
	 */
	public CloseDLGDialog(Frame owner, String meldung) {
		super(owner);
		this.meldung=meldung;
		initialize();
	}

	/**
	 * This method initializes this
	 * 
	 * @return void
	 */
	private void initialize() {
		this.setSize(300, 200);
		this.setContentPane(getJContentPane());
		jLabelMeldung.setText(""+meldung);
		close();
	}

	public void close(){
		System.out.println("closeDLG:"+CloseDLG.clt.stop);
		
		//warten bis CloseDLG.clt.stop = true und dann schliesen		
		
		System.out.println("closeDLG2");
		this.setVisible(false);
	}

	/**
	 * This method initializes jContentPane
	 * 
	 * @return javax.swing.JPanel
	 */
	private JPanel getJContentPane() {
		if (jContentPane == null) {
			jLabelMeldung = new JLabel();
			jLabelMeldung.setText(""+meldung);
			jLabelMeldung.setHorizontalAlignment(JLabel.CENTER);
			jLabelMeldung.setBounds(new Rectangle(20, 30, 200, 20));
			jContentPane = new JPanel();
			jContentPane.setLayout(null);
			jContentPane.add(jLabelMeldung, null);
		}
		return jContentPane;
	}

}

thx für hilfe
mfg Kala

 

[André Uhres]

Ein klassisches Synchronisationsproblem. Dies wird dir weiterhelfen: Java und die Synchronisation

 

[Kaladial]

hmmm gelesen hab ich es aber nicht so richtig verstanden .. hmm können wir das net ma an meinem beispiel durchgehn ?

weil ich hab nich so richtig die idee wo ich nun ansetzten soll

 

[André Uhres]

Erstmal folgendes Beispiel mit wait und notify:
Der CloseDLGThread sendet andauernd im 10 Sekunden Takt notify Anweisungen.
Wenn der CloseDLGDialog dann grad sichtbar ist, wird er geschlossen.

Dazu benötigen wird zunächst ein Objekt, das den Lock darstellt:

public class CloseDLG extends JFrame {
    protected static final String closeLock = "closeLock";

Da wir hier einen ewigen Thread haben wollen, testen wir bei jeder User Action,
ob er schon besteht und initialisieren die Bedingungsvariable der Synchronisation (stop=false):

               public void actionPerformed(java.awt.event.ActionEvent e) {
                    if (clt == null || !clt.isAlive()) {
                        clt = new CloseDLGThread();
                        clt.start();
                    }
                    synchronized(closeLock){
                        clt.stop = false;
                    }
                    go();
                }

Beim Dialog benutzen wir auch immer dieselbe Instanz und rufen seine close() Methode auf,
ehe wir ihn sichtbar machen:

   private CloseDLGDialog dlg;
...
    public void go() {
        if (dlg == null) {
            dlg = new CloseDLGDialog(this, "Starte Com-Port-Verbindung");
            dlg.setTitle("Starte Com-Port-Verbindung");
            dlg.setModal(true);
        }
        dlg.close();
        dlg.setVisible(true);
    }

Da unser CloseDLGThread ewig läuft, setzen wird "running" entsprechend auf true:

public class CloseDLGThread extends Thread {
    boolean running = true;

In der run() Methode von CloseDLGThread synchronisieren wir auf "closeLock",
setzen die Bedingungsvariable (stop=true) und senden den notify:

               while (running) {
                    try {
                        sleep(10000L);
                        synchronized(CloseDLG.closeLock){
                            stop = true;
                            System.out.println("notify");
                            CloseDLG.closeLock.notify();
                        }
                    } catch (Exception e) {
                    }
                }

Da wir wir vom CloseDLGDialog immer ein und dieselbe Instanz verwenden,
rufen wir die Methode close() nicht im Konstruktor auf:

  private void initialize() {
      this.setSize(300, 200);
      this.setContentPane(getJContentPane());
      jLabelMeldung.setText(""+meldung);
      //close();//<---------------------------
   }

Die close() Methode startet jeweils einen neuen Thread, der auf "closeLock" synchronisiert wird
und den CloseDLGDialog schliesst sobald "closeLock" freigegeben wurde und die Bedingung stimmt (stop):

    public void close() {
        //warten bis CloseDLG.clt.stop = true und dann schliesen      
        new Thread(new Runnable() {

            public void run() {
                synchronized (CloseDLG.closeLock) {
                    while (!CloseDLG.clt.stop) {
                        try {
                            System.out.println("wait");
                            CloseDLG.closeLock.wait();
                        } catch (InterruptedException ex) {
                        }
                    }
                    CloseDLGDialog.this.setVisible(false);
                }
            }
        }).start();
    }

Ich hoffe, das hilft dir ein wenig weiter.


Bemerkung: Damit wir im Fall von manuellem Schliessen nicht unnötig Threads erzeugen,
könnten wir z.B. zu Beginn der close() Methode zusätzlich noch prüfen, ob schon einer läuft:

   private Thread closeThread;
...
    public void close() {
        if(closeThread != null && closeThread.isAlive()){
            return;
        }
        //warten bis CloseDLG.clt.stop = true und dann schliesen     
        closeThread = new Thread(new Runnable() {
...
        });
        closeThread.start();
    }

 

[Kaladial]

wunderbar danke für die erklärung hat auf anhieb funktioniert