Thread startet anderen Thread neu

[Bwana]

Hi,

ich hab ein Problem mit zwei Threads, hab mich auch schon viel hier im Forum in den Themen über Threads umgesehen, aber noch nichts gefunden, was mich meiner Lösung weiterbringt, deshalb hab ich ein kleines Mini-Beispiel geschrieben, dass mein Problem verdeutlicht.

Zum Hintergrund:
Ich schreibe ein kleines Matheprogramm (für Grundschüler). Im Übungsmodus wird eine Aufgabe angezeigt und -um ein bisschen Druck aufzubauen ;-)- ein Countdown (in einem Thread) gestartet. Es existieren jetzt 2 Möglichkeiten, wie der Schüler an eine neue Aufgabe (inkl. Neustart des Countdowns) kommt:

a) der Countdown ist auf 0 (thread beendet) -> ein wartender Thread "joiningThread" stößt eine neue Aufgabe an

b) der Schüler ist vorher fertig und drückt einen Button "nächste Aufgabe". Hier müssen die beiden noch laufenden alten Threads abgebrochen und das Ganze neu angestoßen werden. Hier liegt mein Problem! Eigentlich dürften auf diese Weise immer nur EIN countdown-thread und EIN joiningThread am leben sein...es sind aber leider mehr...Es klappt nicht und ich hab das Gefühl, dass ich konzeptuell irgendwie falsch denke...ich möchte die Countdown-Klasse öfter in unterschiedlichen Situationen benutzen, deshalb kann ich die an-den-Thread-anschließende Methode nicht einfach an dessen Ende setzen, sondern muss sie von extern aufrufen.

Hier mal ein kompilierbares Mini-Beispiel:

Countdown-Klasse:

import javax.swing.JLabel;

public class Countdown extends Thread {

	private int _countdownTime;
	private JLabel _counterJLabel;

	public Countdown(int countdownTime, JLabel counterJLabel)
	{
		_countdownTime = countdownTime;
		_counterJLabel = counterJLabel;
		_counterJLabel.setText(""+_countdownTime);
	}
	
	@Override public void run() 
	  { 
		
			while(_countdownTime > 0 && !isInterrupted())
	        {
					_countdownTime=_countdownTime - 1;
					_counterJLabel.setText(""+_countdownTime);
			
			           try 
			           {
			              Thread.sleep(1000);
			           }
			            
			           catch (InterruptedException e)
			           {
			              System.out.println("Thread interrupted");
			              break;
			           }
	        }
	  }		
	}

und eine kleine GUI-Klasse (in der mein Problem liegt)

import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.BorderLayout;
import java.awt.Dimension;
import javax.swing.JLabel;

import javax.swing.JButton;

public class GUI extends JFrame {

	private JPanel jContentPane = null;
	private JLabel countdownjLabel = null;
	private Thread countdown;
	private Thread joiningThread; 
	private JButton nextjButton = null;
	
	public GUI()
	{
		this.setSize(new Dimension(400, 400));
		this.setContentPane(getJContentPane());
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		startCountdown();
	}


	private JPanel getJContentPane() {
		if (jContentPane == null) {
			countdownjLabel = new JLabel();
			countdownjLabel.setText("Countdown");
			jContentPane = new JPanel();
			jContentPane.setLayout(new BorderLayout());
			jContentPane.add(countdownjLabel, BorderLayout.CENTER);
			jContentPane.add(getNextjButton(), BorderLayout.NORTH);
		}
		return jContentPane;
	}
	
	private JButton getNextjButton() {
		if (nextjButton == null) {
			nextjButton = new JButton();
			nextjButton.setText("nächster Countdown");
			nextjButton.addActionListener(new java.awt.event.ActionListener() {
				public void actionPerformed(java.awt.event.ActionEvent e) {
					
					/*****************************************
					 * hier liegt mein Problem
					 *****************************************/
					
					//aktuelle, noch laufende Threads beenden
					countdown.interrupt();
					joiningThread.interrupt();
					
					//neuen Runde starten
					startCountdown();
				}
			});
		}
		return nextjButton;
	}
	
	private void startCountdown()
	{
		countdown = new Thread( new Countdown(10, countdownjLabel));
		countdown.setName("countdown thread");
		countdown.setDaemon(true);
		//startet den Countdown und den Thread, der auf dessen Ende wartet und dann das Ganze neustarten soll
		countdown.start();
		joiningThread();
	}


	private void joiningThread()
	{
		joiningThread =	new Thread()
		{
			public void run() {
				while(!isInterrupted())
				{
				    try {
				    	//warten bis Countdown-Thread zu Ende, sprich Countdown = 0
						countdown.join();
					} catch (InterruptedException e)
{
						System.out.println("Thread interrupted");
					}
					//neue Runde starten
					startCountdown();
				}
			};	
		};
		joiningThread.setDaemon(true);
		joiningThread.start();    
	}
}

der Vollständigkeit halber

public class Main {
	public static void main(String[] args) {

		GUI gui = new GUI();
		gui.setVisible(true);
	}
}

Muss zugeben, dass meine java-skills etwas eingerostet sind, aber ich probier jetzt schon seit 2 Tagen daran rum. Wäre super wenn mir jemand helfen könnte.

Danke!

 

[Michael...]

Für was benötigst Du den "joiningThread"? Der "countdown" Thread kann doch einfach nach Ablauf des Countdowns die nächste Aufgabe anstossen - quasi das gleiche was der Button auch macht.

 

[Bwana]

ich möchte die Countdown-Klasse öfter in unterschiedlichen Situationen benutzen, deshalb kann ich die an-den-Thread-anschließende Methode nicht einfach an dessen Ende setzen, sondern muss sie von extern aufrufen.

mir ist schon klar, dass dein Vorschlag die einfachste Lösung wäre, aber

1. möchte ich die Countdown-Klasse so allgemein wie möglich halten
2. abgesehen vom ein Pragmatischen, möchte ich allein schon aus Neugier wissen, warum oben beschriebener Code nicht läuft.

thx

 

[Michael...]

So nach kurzem Überfliegen, hier mal ein paar Anmerkungen:
- die Klasse Countdown sollte nicht Thread erweitern, sondern Runnable implementieren
- auch wenn der Anwender die Zeit verstreichen lässt, kommen Deine Threads ganz schön durcheinander. Es laufen mehrerer Deiner "joiningThreads" parallel, dadurch vervielfacht sich die Threadanzahl nach jedem Countdown.
- wenn dann der Anwender auch noch den Button drückt kommt noch ein weiterer Multiplikator hinzu, da einmal durch das Drücken und durch den/die "sterbenden" joinedThreads die startCountdown mehrfach aufgerufen wird

Würde Dir raten Dein Konzept zu überdenken. Du könntest z.B. ein Interface definieren, das jedes Objekt, das den Countdown nutzen möchte implementieren muss. Im Konstruktor der Countdown Klasse übergibst Du dann dieses Objekt und der Countdown ruft nach Ablauf der Zeit die implementierte Methode auf.

 

[Bwana]

Hi,

vielen Dank für deine Antwort.
Dass sich meine Threads wie wild vermehren hab ich auch schon bemerkt, ich frag mich nur wieso??? Eigentlich interrupte ich doch die alten bevor ich neue starte?!! würde gern verstehen wo mein Denkfehler liegt...

Das mit dem Interface hört sich vernünftig an, vielen Dank, das werd ich mal versuchen und mich dann nochmal melden.

 

[Bwana]

Das mit dem Interface klappt super und hält auch meine Countdown-Klasse schön allgemein.
Danke!
Trotzdem würd ich immer noch gerne wissen, was an meinem Code falsch war :-(...

 

[Michael...]

Ein Fehler liegt u.a. in Zeile 77 der Klasse GUI:

	while(!isInterrupted())

hiermit erzeugst Du in dem "joinedThread" eine Schleife, die Du doch eigentlich garnicht benötigst. Er sollte ja nur warten bis der Countdown-Thread tot ist, um dann die Methode startCountdown() aufzurufen und dann selbst zu sterben.
D.h. "die joinedThreads" leben ewig, ausser sie werden durch einen Buttonclick gestoppt, aber selbst in diesem Fall wird dann die Methode startCountdown() einmal durch den sterbenden Thread und einmal aufgrund des Buttonclicks aufgerufen und man hat wieder mindestens einen ewiglebenden Thread mehr...

 

[Bwana]

jetzt ist der groschen gefallen!
Vielen Dank!