Thread-/ Simulations- Problem

[Chris42]

Hallo Leute,
Ich hab Probleme damit die Ausführungsgeschwindigkeit einer Simulation zu steuern, dazu erst einmal ein paar Infos.

Momentan muss ich für die Uni den Hamster Simulator nachprogrammieren, dessen wichtigsten Bestandteile sind ein Editor in dem man neue Befehle für den Hamster in Java programmieren kann und ein JPanel indem der Hamster visuell in einer 2D- Welt dargestellt wird.
In dem JPanel wird der Hamster und sein Territorium dargestellt. Diese beiden Klassen bilden auch das Model.
Der Hamster ist von einer Klasse Actor abgeleitet und hat dementsprechend schon einen Befehlssatz. Man kann den selbstgeschriebenen Code im Editor compilieren und dann wird der Hamster durch einen neuen Hamster ersetzt, dieser besitzt dann die neuen Methoden sowie die Methoden des Actors.

Soweit so gut, jetzt möchte das man eine Simulation starten kann (start, pause, stop, JSlider für die Ausführungsgeschwindigkeit). Die Simulation soll über Threads realisiert werden.

Dazu habe ich einen Simulations_Manager indem geschaut wird welcher der Buttons gedrückt wurde und indem geprüft wird ob der Wert des JSliders verändert wurde.

public class SimulationManager implements ActionListener {
	JToggleButton play;
	JToggleButton pause;
	JToggleButton stop;
	
	boolean running;
	boolean paused;
	
	Simulation simulation;

	public SimulationManager(JToggleButton play, JToggleButton pauseButton,
			JToggleButton stopButton, Simulation simulation) {
		this.play = play;
		this.pause = pauseButton;
		this.stop = stopButton;
		this.simulation = simulation;
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		if (e.getSource() == this.play) {
			this.simulation.startSimulation();
		} else if (e.getSource() == this.stop) {
			this.simulation.stopSimulation();
		} else if (e.getSource() == this.pause) {
			this.simulation.pauseSimulation();
		}
	}
}

Wenn der play- Button gedrückt wird soll die Simulation gestartet werden, hier liegt mein Problem:
Es soll nämlich die Main- Methode des momentan aktiven Actors/Hamsters ausgeführt werden, das habe ich soweit auch hinbekommen, allerdings habe ich keine Möglichkeit gefunden wie ich wärend der Ausführung der Main- Methode die Ausführungsgeschwindigkeit anpassen kann.
Mir ist klar das dies mit Thread.sleep(sleepTime) passieren sollte, allerdings wird die Main- Methode direkt als ganzes ausgeführt, ich hätte das aber gerne so, das die Main- Methode quasi Schritt für Schritt ausgeführt wird.

public class Simulation extends Thread implements Runnable, Observer {

	// volatile Thread thread;
	Territorium terri;
	// TODO Schieberegler für Geschwindigkeit
	volatile int sleepTime;

	public Simulation(Territorium territorium) {
		this.terri = territorium;
		// this.thread = new Thread();
	}

	@Override
	public void run() {
		Class<?> clas = this.terri.getActor().getClass();
		try {
			Method method = clas.getMethod("main", null);
			String[] params = null;
			try {
				method.invoke(this.terri.getActor(), params);
			} catch (IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalArgumentException e) {
				// TODO Auto-generated catch block
			        e.printStackTrace();
			} catch (InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (NoSuchMethodException e) {
			 // TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	public void startSimulation() {
		this.run();
	}

	public void stopSimulation() {
		this.stop();
	 }

	public void pauseSimulation() {
		 this.interrupt();
	}

	 @Override
	public void update(Observable o, Object arg) {
		if(!(this == null)) {
			 try {
				this.sleep(sleepTime*100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

	}
	
	public void setSleeptime(int fps) {
		this.sleepTime = fps;
	}
}

Jetzt ist meine Frage ob es überhaupt möglich ist die Main- Methode Schritt für Schritt auszuführen, oder wie man das sonst realisieren könnte.
Ich hatte noch gehofft das man das Warten sonst in der update() Methode realisieren kann aber da fehlt mir auch der Ansatz.

Würde mich freuen wenn mir jemand einen Schubs in die richtige Richtung geben kann oder sonst einen Ansatz hat wie das Problem sonst zu lösen ist.

Gruß Chris

 

[Chris42]

push..

 

[InfectedBytes]

ich bin mir nicht ganz sicher ob ich dein problem richtig verstanden habe, aber wieso rufst du beim ändern des sliders nicht einfach simulation.setSleepTime(...) auf?

 

[Chris42]

Hi InfectedBytes,

über simulation.setSleepTime(...); kann ich ein delay einbauen das ist richtig. Habe ich auch schon getan, hier ist mal die Sliderklasse:

package simulation.controller;

import javax.swing.JSlider;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

public class SliderListener implements ChangeListener {

	Simulation sim;
	int fps;

	public SliderListener(Simulation simulation) {
		this.sim = simulation;
		this.fps = 0;
	}

	@Override
	public void stateChanged(ChangeEvent e) {
		JSlider source = (JSlider) e.getSource();

		fps = (int) source.getValue();

		this.sim.setSleeptime(fps*10);
	}
}

Beim starten der Simulation ist die Verzögerung dann auch da, nur vor dem Aufruf der main- Methode. Also wird die gesamte main()- Methode des aktuellen Actors ausgeführt. Zur Veranschaulichung mal ein kleines Beispiels.

Angenommen der Benutzer schreibt eine main()- Methode für den Actor die folgendermaßen aussieht:

void main() {
    while(vornFrei()) {
        vor();
    }
}

(Der Actor verfügt immer über die Methoden vornFrei, vor, nachLinksDrehen, prüfenObEineMauerDenWegVersperrt, etwasEinsammeln, etwasRauswerfen)

Dann würde soabld ich die Simulation starte, dem Slider entsprechend gewartet werden und dann die main()- Methode ausgeführt werden und der Actor würde direkt am Ende der Karte stehen.
Ich würde das aber gerne so haben, das die View, also das Panel nach jedem Aufruf von vor(); neu gezeichnet wird.

Ich bräuchte also einen Mechanismus dafür das die main- Methode nach jedem Methodenaufruf der in ihr geschieht erst einmal das repaint des Panels aufruft, dann wieder einen Methodenaufruf macht usw (Also müsste theoretisch alles was in der main()- Methode ist Schritt für Schritt ausgeführt werden).
Aber ich glaube über Reflection kann man nur die gesamte main- Methode ausführen oder?

 

[InfectedBytes]

du könntest in jeder Hamstermethode repaint aufrufen.

public void vor() {
//vorwärts gehen
repaint();
}

Im Grunde kannst du dort auch ein sleep einbauen, damit alles langsamer abläuft.

 

[Chris42]

Ich sollte vielleicht hinzufügen das ich mit dem Observer- Pattern arbeite.
Das Model meines Projektes besteht aus den Klassen Actor und Territorium. Beide erben von der Klasse Observable.
Das Territorium_Panel ist meine View und implementiert Observer.

Jede Methode die etwas an der View verändert ruft die Methoden setChanged(); und notifyObservers(); auf.
Wird dann nicht automatisch die überschriebene Methode update(); des Territorium_Panels aufgerufen?

Demnach müsste ich die Verzögerung durch den Slider in der update()- Methode des Territorium_Panels durchführen oder?

 

[InfectedBytes]

wenn du das sleep in der update methode machst, solltest du dir im Klaren sein, dass jede Änderung des Models zu einem sleep führt! d.h. wenn du ein reset durchführst und die listener aufgerufen werden, dann wird auch sleep ausgeführt.

Daher würde ich das sleep lieber direkt in die Methoden vor() etc. schreiben, da diese ja nur innderhalb des Simulationsthread aufgerufen werden

 

[Chris42]

Ah das habe ich nicht bedacht, hast natürlich recht. Ich werde die Methoden mal anpassen und meld mich dann nochmal falls es Probleme gibt.
Bis hierhin erstmal vielen Dank für deine Hilfe

 

[Chris42]

Funktioniert leider nicht.
Habe jetzt in der vor()- Methode das sleep() eingebaut.

Wenn ich über Reflection einmal die vor()- Methode aufrufe funktioniert das super. Aber wenn ich die Simulation starte und die main()- Methode aufgerufen wird, dann schläft der Thread x*sleeptime (x sind die Anzahl an vor()- Aufrufen die der Actor insgesamt machen würde) und dann springt der Actor an die Stelle wo er nach dem durchlaufen der main()- Methode wäre.

 

[InfectedBytes]

du hast den Thread falsch verwendet!
du rufst die Methode startSimulation auf, welche selbst die run methode aufruft, dadurch geschieht aber alles im gleichen Thread.
du musst den Thread mit der start-Methode starten. Also einfach direkt simulation.start() dadurch wird dann die run methode im eigenen Thread ausgeführt.

Ansonsten kann es nicht schaden mal zu schreiben wie denn deine vor methode aussieht.

 

[Chris42]

Ich habe das mit den Threads echt noch nicht begriffen glaube ich..

Also im SliderListener setze ich die sleepTime je nach Sliderstufe. Momentan in der Actorklasse:

package simulation.controller;

import javax.swing.JSlider;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

public class SliderListener implements ChangeListener {

	Simulation sim;
	int fps;

	public SliderListener(Simulation simulation) {
		this.sim = simulation;
	}

	@Override
	public void stateChanged(ChangeEvent e) {
		JSlider source = (JSlider) e.getSource();
		fps = (int) source.getValue();
		this.sim.terri.getActor().setSleepTime(fps * 100);
		// this.sim.setSleeptime(fps*100);
	}
}

In dem SimulationManager soll ich jetzt den Thread starten richtig? Dann sieht das folgendermaßen aus:

package simulation.controller;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JToggleButton;

import simulation.model.Territorium;

public class SimulationManager implements ActionListener {
	JToggleButton play;
	JToggleButton pause;
	JToggleButton stop;
	
	Simulation simulation;

	public SimulationManager(JToggleButton play, JToggleButton pauseButton,
			JToggleButton stopButton, Simulation simulation) {
		this.play = play;
		this.pause = pauseButton;
		this.stop = stopButton;
		this.simulation = simulation;
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		if (e.getSource() == this.play) {
			this.simulation.start();
		} else if (e.getSource() == this.stop) {
			this.simulation.stopSimulation();
		} else if (e.getSource() == this.pause) {
			this.simulation.pauseSimulation();
		}
	}
}

Die Threadklasse Simulation sieht dann so aus:

package simulation.controller;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Observable;
import java.util.Observer;

import simulation.model.Actor;
import simulation.model.Territorium;
import exception.EndException;

public class Simulation extends Thread implements Runnable, Observer {

	public Thread thread;
	Territorium terri;
	boolean pause = false;
	public int sleepTime;

	public Simulation(Territorium territorium) {
		this.terri = territorium;
		this.thread = new Thread();
	}

	@Override
	public void run() {
		Class<?> clas = this.terri.getActor().getClass();
		try {
			Method method = clas.getMethod("main", null);
			String[] params = null;
			try {
				method.invoke(this.terri.getActor(), params);
				synchronized (this) {
					while (this.pause) {
						try {
							this.thread.wait();
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
				}
			} catch (IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalArgumentException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public void startSimulation() {
		if (this.thread == null) {
			this.thread = new Thread(this);
			this.thread.start();
		}
	}

	public void stopSimulation() {
		this.thread.stop();
	}

	public void pauseSimulation() {
		if (this.pause) {
			this.pause = false;
		} else {
			this.pause = true;
		}
	}

	@Override
	public void update(Observable o, Object arg) {
		if (this.thread == null) {
			try {
				throw new EndException();
			} catch (EndException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	// public void setSleeptime(int sleepTime) {
	// this.sleepTime = sleepTime;
	// }
}

Hier ist die move()- Methode der Actorklasse, für den Fall das der Actor nach Norden schaut.

public void move() {
		synchronized (this.territorium) {

			boolean hadCorn = this.territorium.getHadCorn();

			try {
				switch (viewingDirection) {
				case (FACE_TO_NORTH):
					if (!this.territorium.nextIsWall(this.actY, this.actX)) {
						if (this.territorium.nextHasCorn(this.actY, this.actX)) {
							this.territorium.setHadCorn(true);
						} else {
							this.territorium.setHadCorn(false);
						}
						this.actY -= 1;
						territorium.tiles[this.actY][this.actX] = ACTOR_AT_TILE;
						if (hadCorn) {
							territorium.setCorn(actY + 1, actX);
						} else {
							territorium.clearPosition(actY + 1, actX);
						}
						break;
					} else {
						try {
							throw new DeadException();
						} catch (DeadException e) {

						}
					}
					try {
						Simulation.sleep(this.sleepTime);
					} catch (InterruptedException e1) {
						// TODO Auto-generated catch block
						e1.printStackTrace();
					}
					break;
                                // die anderen Fälle...
                                } //Switch Ende.
                         	
                                this.setChanged();
			        this.notifyObservers();

Das Problem bleibt aber weiterhin bestehen, die main()- Methode wird komplett bearbeitet und dann kommt das neuzeichnen der View.

 

[Chris42]

Ach f... hab den Fehler gefunden, ich musste das sleep natürlich vor dem break; ausführen.....

try {
				switch (viewingDirection) {
				case (FACE_TO_NORTH):
					if (!this.territorium.nextIsWall(this.actY, this.actX)) {
						if (this.territorium.nextHasCorn(this.actY, this.actX)) {
							this.territorium.setHadCorn(true);
						} else {
							this.territorium.setHadCorn(false);
						}
						this.actY -= 1;
						territorium.tiles[this.actY][this.actX] = ACTOR_AT_TILE;
						if (hadCorn) {
							territorium.setCorn(actY + 1, actX);
						} else {
							territorium.clearPosition(actY + 1, actX);
						}
						try {
							Simulation.sleep(this.sleepTime);
						} catch (InterruptedException e1) {
							// TODO Auto-generated catch block
							e1.printStackTrace();
						}
						break;
					} else {
						try {
							throw new DeadException();
						} catch (DeadException e) {

						}
					}
					
					break;
                          } // End

Dann nochmal besten Dank für deine Zeit und Mühen, funktioniert jetzt 100%ig

 

[InfectedBytes]

deine Thread klasse sieht wirklich ziemlich durcheinander, insbesondere deine startSimulation methode ist ziemlich...merkwürdig^^
hier einmal ein ganz kurzes beispiel wie du threads verwendest:

public class MyThread extends Thread {
  public void run(){
    //hier kommt deine logik rein, welche parallel zu dem eigentlich programm laufen soll
    //z.b. eben der Aufruf deiner Hamster-Main
  }
}

dort wo du den Thread starten willst:

//...
MyThread thread = new MyThread();
thread.start();

In deiner Threadklasse erzeugst in der startSimulation einen neuen thread welchen du startest, anstatt eben den thread selbst zu starten

p.s. schön das dein problem gelöst wurde^^

 

[Chris42]

Okay, hab meine Klassen mal etwas angepasst. Arbeite jetzt auch das erste mal mit Threads wie man sicherlich gemerkt hat und war irgentwann doch sichtlich verwirrt was das ganze Thema angeht.
Jetzt setz ich mich erstmal ans Code aufräumen

 

[Chris42]

Hi Leute,
ich brauch wohl noch einmal eure Hilfe..

Ich versuche jetzt den Thread den ich gestartet habe zu pausieren/fortzusetzen und den Thread zu stoppen wenn man auf die entsprechenden Buttons drückt.

Leider scheint einfach gar nichts zu passieren, das "pause flag" wird allerdings gesetzt..

Hier nochmal die ActionListener Klasse:

package simulation.controller;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JToggleButton;

import simulation.model.Territorium;

public class SimulationManager implements ActionListener {
	JToggleButton play;
	JToggleButton pause;
	JToggleButton stop;

	Territorium terri;
	Simulation simulation;

	public SimulationManager(JToggleButton play, JToggleButton pauseButton,
			JToggleButton stopButton, Territorium terri) {
		this.play = play;
		this.pause = pauseButton;
		this.stop = stopButton;
		this.terri = terri;
		this.simulation = new Simulation(this.terri);
	}

	@Override
	public void actionPerformed(ActionEvent e) {

		if (e.getSource() == this.play) {
			simulation.start();
		} else if (e.getSource() == this.stop) {
			simulation.stopSimulation();
		} else if (e.getSource() == this.pause) {
			if (this.pause.isSelected()) {
				System.out.println("Pause an");
				try {
					simulation.pauseSimulation();
				} catch (InterruptedException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
			} else {
				System.out.println("Pause aus");
				simulation.resumeSimulation();
			}
		}
	}
}

Und hier die Threadklasse:

package simulation.controller;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Observable;
import java.util.Observer;

import simulation.model.Actor;
import simulation.model.Territorium;
import exception.EndException;

public class Simulation extends Thread implements Runnable, Observer {

	Territorium terri;
	private volatile boolean paused = false;
	private Object lock = new Object();

	public Simulation(Territorium territorium) {
		super();
		this.terri = territorium;
	}

	@Override
	public synchronized void run() {
		checkIfPaused();

		Class<?> clas = this.terri.getActor().getClass();
		try {
			Method method = clas.getMethod("main", null);
			String[] params = null;
			try {
				method.invoke(this.terri.getActor(), params);
			} catch (IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalArgumentException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private void checkIfPaused() {
		synchronized (lock) {
			while (paused) {
				try {
					lock.wait();
					System.out.println("waiting..");
				} catch (InterruptedException exc) {

				}
			}
		}
	}

	public void stopSimulation() {
		Simulation.currentThread().stop();
	}

	public void pauseSimulation() throws InterruptedException {
		System.out.println("pause flag set");
		paused = true;
	}

	public synchronized void resumeSimulation() {
		synchronized (lock) {
			paused = false;
			lock.notify();
		}
	}

	@Override
	public void update(Observable o, Object arg) {
		if (Simulation.currentThread().getState() == Thread.State.TERMINATED) {
			try {
				throw new EndException();
			} catch (EndException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

Hat vielleicht jemand eine Idee woran das liegen kann? Habe mir jetzt schon diverse Beispiele angesehen und eingentlich tue ich genau das gleiche wie die anderen.

 

[InfectedBytes]

ich vermute mal dass du die Methode checkIfPaused nicht aufrufst.
da diese Methode solange wartet, bis nicht mehr pausiert ist, musst du sie eben auch an den Stellen platzieren, welche pausieren sollen.
also z.b. innerhalb deiner vor() Methode.

 

[Chris42]

Oh wow.. Quasi wieder in das gleiche Problem gelaufen wie vorhin auch. Na super, naja jetzt gehts.

Danke nochmal.

 

[Chris42]

Gibt es eine Möglichkeit den Thread komplett zu killen? Habe das mit der stopSimulation() und der checkIfStopped() Methode versucht aber der bleibt bei mir immer an dem lock Object hängen glaube ich, dann passiert nämlich nichts bis ich das Programm in Eclipse kille.

Listener:

@Override
	public void actionPerformed(ActionEvent e) {
		if (e.getSource() == this.play) {
			simulation.start();
			simulation = new Simulation(this.terri);
		} else if (e.getSource() == this.stop) {
			simulation.stopSimulation();
		} else if (e.getSource() == this.pause) {
			if (!paused) {
				paused = true;
				simulation.pauseSimulation();
			} else {
				paused = false;
				simulation.resumeSimulation();
			}
		}
	}

Thread:

package simulation.controller;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Observable;
import java.util.Observer;

import simulation.model.Territorium;
import exception.EndException;

public class Simulation extends Thread implements Runnable, Observer {

	Territorium terri;
	private volatile boolean paused = false;
	private volatile boolean stop = false;
	private Object lock = new Object();

	public Simulation(Territorium territorium) {
		super();
		this.terri = territorium;
	}

	@Override
	public synchronized void run() {
		Class<?> clas = this.terri.getActor().getClass();
		try {
			Method method = clas.getMethod("main", null);
			String[] params = null;
			try {
				method.invoke(this.terri.getActor(), params);
			} catch (IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalArgumentException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println(this.getState());
	}

	public void checkIfPaused() {
		synchronized (lock) {
			while (paused) {
				try {
					lock.wait();
				} catch (InterruptedException exc) {
					Thread.currentThread().interrupt();
					return;
				}
			}
		}
	}

	public void checkIfStopped() {
		synchronized (lock) {
			while (stop) {
				synchronized (lock) {
					lock.notifyAll();
				}
			}
		}
	}

	public void stopSimulation() {
		stop = true;
	}

	public void pauseSimulation() {
		paused = true;
	}

	public void resumeSimulation() {
		paused = false;
		synchronized (lock) {
			lock.notifyAll();
		}
	}

	@Override
	public void update(Observable o, Object arg) {
		if (stop) {
			try {
				throw new EndException();
			} catch (EndException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

vor()- Methode:

public void move() {
		synchronized (this.territorium) {
			try {
				sim = (Simulation) Simulation.currentThread();
				sim.checkIfPaused();
				sim.checkIfStopped();
			} catch (ClassCastException c) {

			}
			boolean hadCorn = this.territorium.getHadCorn();

			try {
				switch (viewingDirection) {
				case (FACE_TO_NORTH):
					if (!this.territorium.nextIsWall(this.actY, this.actX)) {
						if (this.territorium.nextHasCorn(this.actY, this.actX)) {
							this.territorium.setHadCorn(true);
						} else {
							this.territorium.setHadCorn(false);
						}
						this.actY -= 1;
						territorium.tiles[this.actY][this.actX] = ACTOR_AT_TILE;
						if (hadCorn) {
							territorium.setCorn(actY + 1, actX);
						} else {
							territorium.clearPosition(actY + 1, actX);
						}
						try {
							Simulation.sleep(this.sleepTime);
						} catch (InterruptedException e1) {
							// TODO Auto-generated catch block
							e1.printStackTrace();
						}
						break;
					} else {
						try {
							throw new DeadException();
						} catch (DeadException e) {

						}
					}
					break;

                         // ....other cases

 

[InfectedBytes]

Das Problem ist, dass du einen Thread stoppen willst, dessen Programmcode eben noch nicht komplett abgearbeitet wurde. Ein Möglichkeit diesen "kontrolliert" zu stoppen wäre es Exceptions zu "missbrauchen".

Dazu erstellst du dir eine neue Exception Klasse, welche du beim stop wirfst.

public class StopException extends Exception { }

die run Methode deines Threads änderst du dann wie folgt ab, damit eine StopException dazu führt, dass der Thread verlassen wird.

public void run() {
  try {
    //dein "normaler" code, also die main ausführen oder ähnliches
  } catch(StopException e) {
    //gezielter Stopp
  }
}

Und natürlich musst du dann deine verschiedenen Methoden auch anpassen.

public void vor() throws StopException {
  //normaler code
  if(stop) throw new StopException();
}