# Thread beenden (von anderer Klasse)



## Berni92 (25. Mai 2010)

Also wie gesagt ich möchte gerne einen Thread beenden. Mein Programm sieht ungefähr so aus: 


```
public class Game {
   public static void main() {
        JFrame f = new JFrame();
        
        GameField gf = new GameField();
        f.add(gf);
    }
}


public class GameField implements Runnable{

        public Thread thr = new Thread(this);
        public beendet = false;

        public GameField() {
                thr.start();
        }

        public void run() { 
                while(!beendet) { DoSomething();
                }
        }

        public void stopThread() {
                beendet = true;
        }

}

public class Bsp() {        //Spiel soll von hier aus beendet werden können
        public Bsp() { GameOver gov = new GameOver(); }
        
}

public class Bsp2() {        //und von hier aus auch
        public Bsp2() { GameOver gov = new GameOver(); }
}

public class GameOver() {
        public GameOver() {
                Out.print("GAME OVER");
                // HIER MÖCHTE ICH DEN THREAD STOPPEN
        }
}
```


----------



## SlaterB (25. Mai 2010)

ein Thread beendet man, indem man die run-Methode auslaufen läßt,
falls dort eine while(true)-Schleife drin ist, dann diese in while(!beendet) umbauen usw.

der angegebene Thread scheint aber doch sofort beendet zu werden, oder nicht?

thr.stop();
besser nicht aufrufen


----------



## Marco13 (25. Mai 2010)

Threads darf man nicht beenden, man muss sie in den Selbstmord treiben. 

Im speziellen würde man das GameField etwa so implementieren

```
public class GameField{
 
        private volatile boolean shouldStop = false;
        Thread thr = new Thread(this);
 
        public GameField() {
                thr.start();
        }
 
        public void run() { 
                while (!shouldStop)
                {
                    tuWasDuTunMusst();
                }
        }
 
        public void stopThread() {
                shouldStop = true;
        }
 
        public void fehler() {
                GameOver go = new GameOver();
        }
}
```

Alternative wäre höchstens thread.interrrupt(), aber da muss man aufpassen, dass man alles richtig aufräumt, siehe [JavaSpecialists 056] - Shutting down threads cleanly


----------



## Berni92 (25. Mai 2010)

Ja da hab ich mich vertan .... 

Ja in der run Methode is eine while(true) schleife .. 
Die Fehler Methode steht wieder in einer anderen Klasse (das Spiel kann durch mehrere Möglichkeiten Beendet werden)

Besteht keine Möglichkeit aus der  GameOver - Klasse den Thread zu beenden?


----------



## Berni92 (25. Mai 2010)

ok danke werd ich gleich mal probieren ...


----------



## FArt (25. Mai 2010)

Anstatt ein eigenes Flag einzuführen, würde ich verwenden was schon existiert: Thread#interrupt. Hat den Vorteil, dass man auch keine Sonderlocken bauen muss, wenn der Thread gerade blockiert und das Flag ist voll in den Lebenszyklus eines Thread integriert.


----------



## Marco13 (25. Mai 2010)

Ja, deswegen auch der Link am Ende meines Beitrags, aber auch der "Warnhinweis": Solche Sachen wie
[c]catch (InterruptedException e) { /* ignore */ }[/c]
sieht man halt sehr oft....


----------



## SlaterB (25. Mai 2010)

wenn man nur mit Runnable arbeitet + 
  Thread thr = new Thread(this);
dann ist das auch nicht viel leichter

und dann noch vielleicht ExecutorService 
na das liegt eh noch weiter voraus


----------



## Berni92 (25. Mai 2010)

Ok hab das jez mit dem "Selbstmord" gemacht mein Problem ist aber noch immer das ich den Thread von der GameOver Klasse beenden will.


```
public class GameField{
 
        public boolean shouldStop = false;
        Thread thr = new Thread(this);
 
        public GameField() {
                thr.start();
        }
 
        public void run() { 
                while (!shouldStop)
                {
                    tuWasDuTunMusst();
                }
        }
 
        public void stopThread() {
                shouldStop = true;
        }
 
}

public class GameOver() {
      public GameOver() {
            // Thread stoppen ( Aufruf von stopThread in der GameField Klasse)
      }
}
```


----------



## SlaterB (25. Mai 2010)

du bist fertig

(alternativ Fehler genauer beschreiben)


----------



## Berni92 (25. Mai 2010)

Nein ich weis nicht wie ich den Thread von der GameOver Klasse beenden soll also die stopThread Methode aufrufen ohne ein neues GameFiled erzeugen zu müssen, da dieses s.o. in der main Methode erstellt wird

GameOver wird durch einen Fehler in einem anderen Teil des Spiels aufgerufen


----------



## SlaterB (25. Mai 2010)

es wurden doch paar Vorschälge gemacht, etwa die run-Methode abzubrechen, wie du es auch umgesetzt hast,

was läßt dich jetzt vermuten, dass das Ziel nicht erreicht ist,
wieso stellst du dieselbe Frage unverändert erneut?

wenn du all das zur run-Methode nicht einigermaßen verstehst, dann schreibe das doch


----------



## Berni92 (25. Mai 2010)

ich weis nicht wie ich stopThread() aufrufen soll



```
public class Bsp{
     public Bsp(){
          
     }
     //Hier muss man etwas tun und wenn man einen Fehler macht wird fehler(); aufgerufen
     
     public void fehler() {
          GameOver gov = new GameOver()
     }
}

public class GameOver{
     public GameOver() {
          GameField gf = new GameField();     //funktioniert nicht da ich ja kein neues GameField erzeugen darf sondern das      //bestehende verwenden muss um den Thread zu beenden
          gf.stopThread();
     }
}
```


----------



## SlaterB (25. Mai 2010)

irgendjemand wird GameOver doch erzeugen, der hat vielleicht die Information oder dessen Erzeuger usw.,
wenn wie im ersten Posting GameField selber GameOver erzeugt, dann z.B.

new GameOver(this);
+ im Konstruktor entsprechenden Parameter vorsehen

so enthält GameOver eine Referenz auf GameField


----------



## Berni92 (25. Mai 2010)

Ja da habe ich mich verschrieben ... GameOver wird eben nicht von GameField erzeugt ...


----------



## Berni92 (25. Mai 2010)

Ok habe es geschafft .. war eigentlich ganz einfach 

nur die Methode stopThread() -> static machen und dann in GameOver - Klasse einfach mit GameField.stopThread() aufrufen


----------



## Marco13 (25. Mai 2010)

Neeeinnn... nicht static :noe: 

Was soll denn "GameOver" für eine Klasse sein? Eine Instanz der Klasse "Tisch" ist ein Tisch, eine Instanz der Klasse "GameField" ist ein Spielfeld, und eine Instanz der Klasse "GameOver" ist... ein Spielende?

Vermutlich musst du nur das Objekt im Konstruktor übergeben

```
public class Bsp{


    private GameField gameField;

     public Bsp(){
          gameField = new GameField();
          gameField.start();
     }
     
     public void fehler() {
          GameOver gov = new GameOver(gameField);
     }
}
 
public class GameOver{
     public GameOver(GameField gf) {
          gf.stopThread();
     }
}
```
So _funktioniert_ das. Sinn macht es keinen, aber ... das ist ja egal...


----------



## Berni92 (25. Mai 2010)

Geht leider nicht .. da das GameField in der Main Methode erzeugt wird siehe 1. Post und der Fehler in 2 Verschiedenen Klassen vorkommen kann (deshalb die GameOver - Klasse)

€: hab jez den 1. Post nochmal überarbeitet .. war einiges falsch


----------



## Marco13 (25. Mai 2010)

:noe: Tu' mal so, als würde es funtkionieren, und skizziere dann, wie du das gerne verwenden würdest. 

Man kann nur sagen: Dort, wo der Thread beendet werden soll, muss direkt oder indirekt(!) der Thread (bzw. das GameField) auch bekannt sein. Man könnte jetzt das GameField in der Gegend rumreichen, oder ein anderes Objekt, aber solange man nicht weiß, auf welchem Objekt die stop-Methode aufgerufen werden soll, sieht's eben schlecht aus..


----------



## Berni92 (25. Mai 2010)

So funktioniert es, auch wenns ein schlechter Stil ist:


```
public class Game {
   public static void main() {
        JFrame f = new JFrame();
        
        GameField gf = new GameField();
        f.add(gf);
    }
}
 
 
public class GameField implements Runnable{
 
        public Thread thr = new Thread(this);
        public static beendet = false;
 
        public GameField() {
                thr.start();
        }
 
        public void run() { 
                while(!beendet) { DoSomething();
                }
        }
 
        public static void stopThread() {
                beendet = true;
        }
 
}
 
public class Bsp() {        //Spiel soll von hier aus beendet werden können
        public Bsp() { GameOver gov = new GameOver(); }
        
}
 
public class Bsp2() {        //und von hier aus auch
        public Bsp2() { GameOver gov = new GameOver(); }
}
 
public class GameOver() {
        public GameOver() {
                Out.print("GAME OVER");
                GameField.stopThread();      // HIER MÖCHTE ICH DEN THREAD STOPPEN
        }
}
```


----------



## Marco13 (26. Mai 2010)

Ohne Static:

```
public class Bsp {        //Spiel soll von hier aus beendet werden können
        public Bsp(GameField gf) { gf.stopThread(); }
}
 
public class Bsp2 {        //und von hier aus auch
        public Bsp2(GameField gf) { gf.stopThread(); }
}
/* WEG: 
public class GameOver() {
        public GameOver() {
                Out.print("GAME OVER");
                GameField.stopThread();      // HIER MÖCHTE ICH DEN THREAD STOPPEN
        }
}
*/
```


----------

