Threads überlagern sich.

[Onkel markus]

Hallo!
Ich habe ein spiel programmiert. Man kann sich selbst per pfeiltasten steuern, man ist ein JLabel (2D).
Das fuinktioniert wunderbar, aber nach einiger Zeit wid das JLabel immer schneller.
Ich habe die Figur (extends JLabel), diese hat genau einen Thread, der die Bewegung angibt.
Dieser wird immer interrupted, wenn die Richtung geändert wird, und dann neu gestartet (mit einem anderen Runnable).

Besonders häufig passiert das, wenn man ganz oft hintereinander die richtung wechselt, sprich wenn der thread sehr häufig interrupted und neu gestartet wird. Ohne interrupted war das noch schlimmer.

Ich glaube mal dass das an der überlagerung von Threads kommt. Aber dazu müsste der trhead nicht richtig beendet worden sein...
oder lkiege ich mit der vermutung falsch?
Ich glaube ein Code bring hier weniger was, weil das problem bei mir fast jedesmal wenn ich sowas mache kommt6 (dieses ist nicht mein erstes Spiel).

Weiß wer woran es liegt?
Wenn ihr doch nen code wollt sagt bescheid....
Mfg ich

 

[madboy]

Fragst du in deinem Thread auch isInterrupted() ab und beendest ihn dann?
Der Code deiner run() Methode wäre wohl hilfreich, ebenso der Code, wie die Threads gestartet und gestoppt werden.

Ich glaube ein Code bring hier weniger was, weil das problem bei mir fast jedesmal wenn ich sowas mache kommt6 (dieses ist nicht mein erstes Spiel).

In dem Fall wird wohl fast jedesmal ein Fehler im Code sein :wink:

 

[Onkel markus]

Danke für deine schnelle antwort!
Hier der thread:

	public class runFRONT implements Runnable {
		public void run() {
			while(getBounds().x>=3&movingf){
				boat.setIcon(new ImageIcon(prog.pre+"grafik/"+Schiff+"/forw.gif"));
				setBounds(getBounds().x-1, getBounds().y, 100,71);
				try{
					Thread.sleep(10);
				}
				catch(InterruptedException e){}
			}
			movingf = false;
			runB();
		}
	}

Davon gibt es zwei stück ,sind beide gleich aufgebaut, einer x + 1, einer x - 1 (klar)

Hier eine der Funktionren , in der der Thread thread (public) aufgerufen wird (nachdem er unterbrochen wurde)

	public void runF(){
		thread.interrupt();
		thread = new Thread(new runFRONT());
		thread.start();
	}

Wieso soll ich abfragen is Interrupted? wenn ich ihn vorher interrupte dann müsste er doch interrupted sein oder verstehe ich da mal wieder was nicht?
Mfg

 

[madboy]

Thread.interrupt() setzt nur ein Flag. Das unterbricht noch nix.
ändere das

while(getBounds().x>=3&movingf){

in

while(getBounds().x>=3&movingf && ! isInterrupted()){

Ausserdem musst du noch

 catch(InterruptedException e){}

ändern in

 catch(InterruptedException e){this.interrupt()}

, weil das "Interrupted-Flag" beim Abfragen zurückgesetzt wird.

 

[Onkel markus]

muss ich dann statt this thread einsetzen? weil meine class will das net haben (=> sagt is undefined for the type shif... etc)
aber wenn ich das mache wird das problem noch stärker. Denn der thread wird ja später neu gestartet. geht dann die funktion weiter?
Ich hab das jetze bei beiden funktionen eingesetzt, wie gesagt mit negativem erfolg;-)

	public class runFRONT implements Runnable {
		public void run() {
			while(getBounds().x>=3&movingf && thread.isInterrupted()==false){
				boat.setIcon(new ImageIcon(prog.pre+"grafik/"+Schiff+"/forw.gif"));
				setBounds(getBounds().x-1, getBounds().y, 100,71);
				try{
					Thread.sleep(10);
				}
				catch(InterruptedException e){thread.interrupt();}
			}
			movingf = false;
			runB();
		}
	}

 

[madboy]

muss ich dann statt this thread einsetzen? weil meine class will das net haben (=> sagt is undefined for the type shif... etc)

this sollte schon korrekt sein.

Denn der thread wird ja später neu gestartet. geht dann die funktion weiter?

Welche Funktion meinst du? Wie ich das verstanden habe, willst du den Thread komplett durch einen neuen ersetzen, also:

Du hast einen Thread, der irgendwas macht.
Diesen Thread willst du beenden und gleich danach einen neuen starten, der was anderes macht.
Diese zwei Threads laufen aber bisher parallel -> das willst du nicht

Soweit korrekt?

 

[Marco13]

Vielleicht kann man auf die eine oder andere Art an den Symptomen rumdoktern, um die sichtbaren Auswirkungen des Problems abzumildern, aber wie wäre es, das Problem garnicht erst entstehen zu lassen? Kurz und prägnant: Für jede Bewegungsrichtung einen derartigen Thread zu erstellen ist Bockmist. Hm. Sorry. Es ist, wie es ist.

 

[Onkel markus]

genau. Das mache ich, damit sie eben nicht parallel laufen. Das tun sie auch scheinbar nicht . Ansonsten würde dach mein schiff stehen bleiben, bzw alle 0.0000003 sekunden die richjting wechseln. oder?

wenn ich das so schreibe:

while(getBounds().x>=3&movingf && ! this.isInterrupted()){

dann sagt er mir:

The method isInterrupted() is undefined for the type ship.runFRONT

Wenn ich schreibe

while(getBounds().x>=3&movingf && ! thread.isInterrupted()){

ist es zwar eigentlic richtig , erfüllt aber seinen sinn nicht => schiff fährt noch schneller als vorher.

Vielleicht kann man auf die eine oder andere Art an den Symptomen rumdoktern, um die sichtbaren Auswirkungen des Problems abzumildern, aber wie wäre es, das Problem garnicht erst entstehen zu lassen? Kurz und prägnant: Für jede Bewegungsrichtung einen derartigen Thread zu erstellen ist Bockmist. Hm. Sorry. Es ist, wie es ist.

Und wie soll es sonst noch gehen?
Eine bewegunbg kann man nur über einen thread darstellen. Ansonsten wird das Panel net repainted, sprich es bleibt stehen bis die funktion zu ende ist und wird dann angezeigt....
oder meinst du dass alle bewegunbgsarten in einen thread gesteckt werden sollen?
mag ich deswegen nicht, weil mein schiffchen relativ oft die richtung wechseln soll. dann Würde das auf ne riesenmenge code auslaufen, diese variante ist sehr viel einfacher (Wenn sie denn klappt). Und es ist sicher möglich einen thread zu überschreiben...

Andere Frage:
Beendet sich ein Thread komplett slebständig, wenn sein Code abgelaufen ist?
=> ist mein Thread tot, sobald die Funbktion runB(); aufgerufen wird?

 

[Marco13]

Eine bewegunbg kann man nur über einen thread darstellen.
Die Hervorhebung hab ich mal eingefügt :wink: Es wäre besser, für die gesamte Bewegung EINEN Thread zu verwenden. Redundanz ist immer redundant. Dass das Schiff von JLabel erbt ist ziemlich sinnfrei. Eigentlich müßten alle Änderungen an diesem Label mit SwingUtilitites.invokeLater in den Event-Dispatch-Thread ausgelagert werden. Insbesondere auch das Setzen des ImageIcons. Aber in JEDEM Bewegungsschritt ein neues ImageIcon zu erstellen und dem Label zuzuweisen ist sowieso Unfug. Das sollte genau dann (einmal!) gemacht werden, wenn sich die Bewegungsrichtung ändert (weil sich nur dann etwas ändert ... äh :roll: tja.). Aber es kommt auch darauf an, wie man die Prioritäten setzt. Gute Programme tun, was sie tun sollen. Programme, die tun, was sie tun sollen, sind aber nicht automatisch gut. Vielleicht kriegst du das Programm ja noch dazu, zu tun, was es tun soll.

 

[Marco13]

EDIT: Ein Teil des obigen Beitrages wurde dazueditiert, während ich schon die Antwort erstellte.
Und zur letzten Frage: Der Thread stirbt selbsttätig,nachdem die Funktion runB aufgerufen wurde.

 

[Onkel markus]

OK stimmt, mit dem Icon. Habs jetzt so gemacht dass ich das icon in der funktion ändere in der später der thread gestartet wird.

Hab jetzt mal anstelle von implements runnable extends Thread genommen (dann gehts mit this.isinterrupted())

	public class runFRONT extends Thread {
		public void run() {
			while(getBounds().x>=3&movingf && ! isInterrupted()){
				setBounds(getBounds().x-1, getBounds().y, 100,71);
				try{
					Thread.sleep(10);
				}
				catch(InterruptedException e){thread.interrupt();}
			}
			movingf = false;
			runB();
		}
	}

OK Problem gelöst.
Ich hab das jetzt vollständig anders gebaut:
Die bewegung liegt nun in einer einzelnen class, extends Thread.
Diese hat die funktionen back und forw, die jedesmal ein booeln überprüft, ob sie weiterfahren oder richting ändern soll.
So muss man von außen nur eben den boolean verändern, und das schiff wendet...
hier die thread klasse:

package objects;

import javax.swing.ImageIcon;

import prog.prog;

public class move extends Thread {
	public ship sh;
	public boolean forward;
	public move(ship s){
		forward = true;
		sh = s;
	}
	public void run() {
		forw();
	}
	public void forw(){
		forward = true;
		sh.boat.setIcon(new ImageIcon(prog.pre+"grafik/"+sh.Schiff+"/forw.gif"));
		while(sh.getBounds().x>=3&forward&!isInterrupted()){
			sh.setBounds(sh.getBounds().x-1, sh.getBounds().y, 100,71);
			sh.repaint();
			try{
				Thread.sleep(10);
			}
			catch(InterruptedException e){sh.thread.interrupt();}
		}
		backw();
	}
	public void backw(){
		forward = false;
		sh.boat.setIcon(new ImageIcon(prog.pre+"grafik/"+sh.Schiff+"/backw.gif"));
		while(sh.getBounds().x<=460 &! isInterrupted() & ! forward){
			sh.setBounds(sh.getBounds().x+1, sh.getBounds().y, 100,71);
			sh.repaint();
			try{
				Thread.sleep(10);
			}
			catch(InterruptedException e){sh.thread.interrupt();}
		}
		forw();
	}
}

Danke dass ihr mir geholfen habt!
Mfg Markus

 

[kleiner_held]

Nur als Nachtrag:
die 2 Änderungen von madboy hätten auch funktioniert, alledings nicht mit:

this.isInterrupted(); und this.interrupt() denn dein runFRONT war in dem Moment ein Runnable und kein Thread (das hat er wahrscheinlich übersehen)

thread.isInterrupted(); und thread.interrupt(); konnte auch nicht gehen, da die Variable thread auf den zuletzt gestarteten Thread verwiesen hat (der ist ja eigentlich nie interrupted) und nicht auf den der das Runnable gerade ausführt.

Richtig wären gewesen: Thread.currentThread().isInterrupted(); und Thread.currentThread().interrupt(); denn damit hättest du genau den Thread gesteuert, der dein Runnable ausführt.

Am Ende ist es aber definitiv besser nur einen Thread laufen zu lassen, der einfach nur eine andere Richtung zugewiesen bekommt.

 

[madboy]

... war in dem Moment ein Runnable und kein Thread (das hat er wahrscheinlich übersehen)

Verflixt. Danke kleiner_held. Ich sollte mir den Code doch immer richtig anschauen, auf den ich antworte :wink:

 

[Marco13]

Auch die letzte Lösung ist (wenn ich das beim ersten Überfliegen richtig erfaßt habe) Unfug, weil du damit früher oder später einen StackOverflowError bekommst, da sich die beiden Methoden bedinungslos gegenseitig aufrufen.

 

[Onkel markus]

wieso bedienungslos?
Die eine funktion wird beendet wenn ich forward ändere (schleifenbedingung geht flöten) und ruft dann planmäßig die andere auf, geht danach selber zuende.
Wo ist das Problem?

 

[kleiner_held]

Wenn die Methoden sich gegenseitig aufrufen wird jeder neue Methodenaufruf in den Stack gelegt. Das Problem daran ist schwierig zu erklären, da es ein paar grundlegende Konzepte der Kompilierung von Kontrollstrukturen vorraussetzt - da sehe ich mich jetzt nicht in der Lage das ein wenigen Worten anschaulich zu erklären. Begnügen wir uns mit der Feststellung von Marco, dass du nach vielen Richtungsänderungen einen java.lang.StackOverflowError bekommst.

Um dich nicht ganz im Regen stehen zu lassen, hier mal der geänderte Code, in der Art wie ich es lösen würde.

public class move extends Thread {
   private ship sh;
   private boolean forward;
   
   private ImageIcon forwardIcon;
   private ImageIcon backwardIcon;

   public move(ship s){
      sh = s;
      forwardIcon = new ImageIcon(prog.pre+"grafik/"+sh.Schiff+"/forw.gif");
      backwardIcon = new ImageIcon(prog.pre+"grafik/"+sh.Schiff+"/backw.gif");
      setForward(true);
   }

   public void run() {
      while(!isInterrupted()) {

         if (forward) {
           if (sh.getBounds().x>=3) {
              sh.setBounds(sh.getBounds().x-1, sh.getBounds().y, 100,71);
              sh.repaint(); // Eigentlich überflüssig, setBounds() sollte das automatisch triggern
           }
         }
         else {
           if (sh.getBounds().x<=460) {
             sh.setBounds(sh.getBounds().x+1, sh.getBounds().y, 100,71);
             sh.repaint();
           }
         }

         try{
            Thread.sleep(10);
         }
         catch(InterruptedException e) {interrupt();}
      }
   }

   public void setForward(boolean forward) {
      this.forward = forward;
      sh.boat.setIcon(forward ? forwardIcon : backwardIcon);
   }
}

Mit dem Aufruf von setForward() kannst du die Richtung ändern, ganz stoppen kannst du den Thread wie gehabt durch interrupt();

PS: bitte Klassenamen immer groß schreiben, ich hab es in dem Beispiel nur so gelassen, damit du dich besser zurechtfindest