Threads kein neues Fenster erzeugen lassen

[Nose]

Hallo zusammen,

ich habe vor Kurzem angefangen mich mit Swing zu beschäftigen und so kam es, dass ich einmal einen simplem Countdown in eine "schöne" GUI verpacken wollte. Also habe ich meinen Konsolenbasierten Countdown versucht zu portieren.
Doch nun kämpfe ich mit dem Problem, dass immer wenn ich einen neuen Thread starte, sich ein neues Fenster öffnet. Weiss hier wer Rat und kann mich auf meinen evtl. kleinen Fehler aufmerksam machen?
Hier mal beide Klassen:

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;

public class GUI extends JFrame implements Runnable{
    
    static Thread threadCounter;
    static pdscounter Counter = new pdscounter();
    static JTextField Anzeige = new JTextField("Zeit:", 0);// 0 für zentiert
    static JLabel Stunden = new JLabel("Stunden:");
    static JLabel Minuten = new JLabel("Minuten:");
    static JLabel Sekunden = new JLabel("Sekunden:");
    static JButton Button = new JButton("Start");
    static JButton Stop = new JButton("Pause");
    static JPanel ButtonPanel = new JPanel();
    static JPanel Zeiten = new JPanel();
    static JPanel Eingaben = new JPanel();
    static JTextField StundenEingabe = new JTextField("0");
    static JTextField MinutenEingabe = new JTextField("0");
    static JTextField SekundenEingabe = new JTextField("0");
    static int status = 0;
    
    public void run(){
	initialisierung();
    }
    
    GUI(){
	super("pds-counter");
	setLayout(null);
	this.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE);
	
	Zeiten.setLayout(new GridLayout(0, 1));
	Eingaben.setLayout(new GridLayout(0, 1));
	ButtonPanel.setLayout(new GridLayout(0, 1));
	
	Zeiten.add(Stunden);
	Zeiten.add(Minuten);
	Zeiten.add(Sekunden);
	Eingaben.add(StundenEingabe);
	Eingaben.add(MinutenEingabe);
	Eingaben.add(SekundenEingabe);
	ButtonPanel.add(Button);
	ButtonPanel.add(Stop);
	
	getContentPane().add(Zeiten);
	getContentPane().add(Eingaben);
	getContentPane().add(ButtonPanel);
	getContentPane().add(Anzeige);
	
	Anzeige.setBounds(10, 50, 150, 50);
	Zeiten.setBounds(10, 190, 75, 75);
	Eingaben.setBounds(90, 190, 50, 75);
	ButtonPanel.setBounds(165, 190, 75, 75);
	
	pack();
	setSize(300, 300);
	setVisible(true);
    }
    
    static void setStatus(int value){
	status = value;
    }
    
    static int getStatus(){
	return status;
    }
    
    public static void initialisierung (){
	
	String Std, Min, Sek;
	int StdConvert=0;
	int MinConvert=0;
	int SekConvert=0;
	
	
	Std = StundenEingabe.getText();
	Min = MinutenEingabe.getText();
	Sek = SekundenEingabe.getText();

	try{
	    StdConvert = Integer.parseInt(Std);
	}catch (NumberFormatException e) {
	}
	
	try{
	    MinConvert = Integer.parseInt(Min);
	}catch (NumberFormatException e) {    
	}
	
	try{
	    SekConvert = Integer.parseInt(Sek);
	}catch (NumberFormatException e) {    
	}
	
	Counter.setStunden(StdConvert);
	Counter.setMinuten(MinConvert);
	Counter.setSekunden(SekConvert);
	GUIcounter();
    }
    
    public static void GUIcounter(){
	for(int time = Counter.calcTime(); time >= 0; time--){
	    Anzeige.setText(Counter.calculation() + " noch uebrig.");
	    
	    System.out.println(Counter.calculation());
	    pdscounter.secondwait(1000L);   
	    Counter.setOverallTime();
	    
	} 	
	Counter.freakingbeep();
	setStatus(2);
	System.out.println(getStatus());
    }
    
    public static void createThread(){
	threadCounter = new Thread(new GUI());
	
    }
    

    public static void main(String args[]){
	//new GUI();
	createThread();
	
	Button.addActionListener(new ActionListener(){
	    public void actionPerformed(ActionEvent e){
		if(getStatus() == 0) threadCounter.start();
		if(getStatus() == 1) threadCounter.resume();
		if(getStatus() == 2){
		    createThread();
		    setStatus(0);
		}
	    }
	    
	});
	
	Stop.addActionListener(new ActionListener(){
	    public void actionPerformed(ActionEvent e){
		
		setStatus(1);
		threadCounter.suspend();
	    }
	    
	});
	
    }
}

import java.awt.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class pdscounter {
    int Stunden, Minuten, Sekunden, overallTime;   
    
    public static void beep(int Anzahl){
	for(int i = 0; i < Anzahl; i++){
	     Toolkit.getDefaultToolkit().beep();
	}
    }
    
    public static void secondwait(long zeit){
	try{
	    Thread.sleep(zeit);
	} catch(InterruptedException e){
	    System.out.println("Fehler!");
	}
    }
    
    public static String eingabeLesen() {
        try {
            return new BufferedReader(new InputStreamReader(System.in)).readLine();
        } catch (IOException io) {
            System.out.println("Fehler!");
            return "";
        }
    }
    
    public static int eingabeInt() {
        try {
            return Integer.parseInt(eingabeLesen());
        } catch (NumberFormatException e) {
            System.out.println("Keine oder falsche Eingabe erfolgt. Setze Eingabe auf 0.");
            return 0;
        }
    }
    
    public void setStunden(int Stunden){
	this.Stunden = Stunden;
    }
    
    public void setMinuten(int Minuten){
	this.Minuten = Minuten;
    }
    
    public int getStunden(){
	return this.Stunden;
    }
    
    public int getMinuten(){
	return this.Minuten;
    }
    
    public void setSekunden(int Sekunden){		
	this.Sekunden = Sekunden;
    }
    
    public int getSekunden(){
	return this.Sekunden;
    }
    
    public int calcTime(){
	this.overallTime = (getMinuten()*60) + (getStunden()*3600) + getSekunden();
	return this.overallTime;
    }
    
    public void setOverallTime(){
	this.overallTime = this.overallTime - 1;
    }
    
    public void setOverallTimeToZero(){
	this.overallTime = 1;
    }
    
    public int getOverallTime(){
	return this.overallTime;
    }
    
    public void freakingbeep(){
	for(int u = 0; u < 2; u++){
		for(int i = 0; i < 10; i++){
		    beep(1);
		    secondwait(50L);
		}
		secondwait(1000L);
	}
    }
    
    /* Calculation führt die Zeitberechnung durch. Dies geschieht durch Modulooperationen
     * an den Gesammtsekunden.
     * Bsp.: Die Stunden:
     * 			Gesammtzeit MOD 3600 ergibt die Restminuten
     * 			Gesammtzeit - (Gesammtzwit MOD 3600) ergibt die Zeit, die ohne Rest
     * 							     teilbar wäre.
     * */
    public String calculation(){
	int stdBuffer, minBuffer, sekBuffer;
	stdBuffer = (getOverallTime()-(getOverallTime()%3600))/3600;
	minBuffer = ((getOverallTime()%3600)-((getOverallTime()%3600)%60))/60;
	sekBuffer = (getOverallTime()%3600)%60;
	
	return stdBuffer+":"+minBuffer+":"+sekBuffer;
    }
    
   
    
    public void counter(){
	for(int time = calcTime(); time >= 0; time--){
	    System.out.println(calculation()+" noch verbleibend.");
	    secondwait(1000L);   
	    setOverallTime();
	} 	
	freakingbeep();
    }
    
}

Zuerst hatte ich das Problem, dass der Swingthread alles blokierte, also habe ich einen neuen Thread erstellt, der das Problem lösen sollte. Das funktioniert auch, bis ich versuche das Ganze neuzustarten, also den User nach Ablauf des Counters neue Werte eingeben lasse.
Also versuchte ich einen neuen Thread zu erstellen, quasi den alten zu "überschreiben". Das scheint allerdings nicht so zu funktionieren, zumindest nicht wie ich es mit erhofft habe, denn ein neuer Thread erzeugt wieder ein neues Fenster.

Ein wenig HIlfe wäre echt nett.
MfG
nose

PS: alles im Eigenstudium beigebracht, bin also für Kritik gerne offen, wenn es um Programmierstil geht.

 

[trazzag]

in Zeile 117 erzeugst du mit jedem neuen Thread eine neue GUI (threadCounter = new Thread(new GUI()) - einfach die alte übergeben, statt eine neue zu erzeugen.

 

[Nose]

Das mag zwar dumm kingen, aber wie stelle ich das an?
Wenn ich new Thread(threadCounter) startet das Programm nichtmehr. Muss ich das in eine neue Klasse auslagern?

MfG
Nose

 

[Wildcard]

Swing ist nicht threadsicher! Jede Swing Methode muss aus dem Event Dispatch Thread (EDT) aufgerufen werden, es sei denn sie ist explizit als threadsicher gekennzeichnet.

 

[Nose]

Gut, dann werde ich mich da mal einlesen. Danke Euch!