"restartable" threads

[minzee]

Hi

Threads kann man leider nur ein einziges mal starten. Ich würde Threads aber gerne beliebig oft starten können.

Das ist dabei herausgekommen:

class T extends Thread
{
   private Boolean self;
   T()
   {
      self = new Boolean(true);
   }
   public void run()
   {
      while(true)
      {
         // Hier irgendwelche Aktionen:
         System.out.println("run");
         try
         {
            Thread.sleep(1000); // 1s
         }
         catch(InterruptedException e) 
         {
         }
         
         // An jedem Schleifenende muss der Thread warten:
         synchronized(self)
         {
            try
            {
               self.wait(); // Thread wird in den Wartepool gelegt
            }
            catch(InterruptedException e) 
            {
            }
         }
      }
   }
   String go()
   {
      State s = getState();
      System.out.println("state: " + s);
      switch(s)
      {
         case RUNNABLE:
         case TIMED_WAITING: // aufgrund des Thread.sleep in run nötig
            return "running";
         case NEW:
            start();
         default:
            synchronized(self)
            {
               self.notify(); // Thread aus Wartepool geholt
            }
      }
      return "started";
   }
}
class Main
{
   public static void main(String[] args)
   {
      T t = new T();
      System.out.println(t.go()); // started
      try
      {
         Thread.sleep(500); // 0.5s
      }
      catch(InterruptedException e) 
      {
      }
      System.out.println(t.go()); // running
      try
      {
         Thread.sleep(1000); // 1s
      }
      catch(InterruptedException e) 
      {
      }
      System.out.println(t.go()); // started
   }
}

Macht man das so? Ist das richtig?

EDIT: Ich glaube, dieses Thema hätte ich im "Codeschnipsel u. Projekte" öffnen sollen, oder?

 

[stg]

Keine Ahnung, ob "man das so (macht)", da ich nicht wirklich verstehe, was du genau vorhast.
Einen Thread mehrmals starten? Wozu soll das gut sein? Entweder läuft er, oder eben nicht. Ein Auto, das fährt, würdest du doch auch nicht nocheinmal starten wollen?! Wenn du mehrere Threads brauchst, die das gleiche machen, dann erstelle einfach mehrere Instanzen von deiner Thread-Klasse.

Die Java API sagt dazu übrigens:
It is never legal to start a thread more than once. In particular, a thread may not be restarted once it has completed execution.

 

[minzee]

Ich habe hier auch keinen echten restartable thread programmiert. Darum steht bei mir im Titel dieses Themas das Wort restartable unter Anführungszeichen.

http://www.java-forum.org/java-basi...asierendes-spiel-architektur.html#post1044862 ist der Grund, warum ich mich für solche "restartable" threads interessiere. Es gibt dort 2 Kategorien von Klassen: jene für Ablaufsteuerung, und jene für Aktionen. Scheinbar können die Aktionen diverse Stati rückmelden, wenn man sie abfragt. Eine davon ist RUNNING. Dieser Status wird rückgemeldet, wenn eine Aktion aktuell noch ausgeführt wird. Darum vermute ich, dass Instanzen von Aktionen-Klassen in eigenen Threads ablaufen. Da man Aktionen sicherlich immer wieder anstoßen kann, vermute ich, dass die Threads "restartable" sein müssen.

Ich glaube, ich konnte das mittlerweile schon etwas vereinfachen (synchronisiere auf this):

class T extends Thread
{
   public void run()
   {
      while(true)
      {
         // Hier irgendwelche Aktionen:
         System.out.println("run");
         try
         {
            Thread.sleep(1000); // 1s
         }
         catch(InterruptedException e) 
         {
         }
         
         // An jedem Schleifenende muss der Thread warten:
         synchronized(this)
         {
            try
            {
               wait(); // Thread wird in den Wartepool gelegt
            }
            catch(InterruptedException e) 
            {
            }
         }
      }
   }
   String go()
   {
      State s = getState();
      System.out.println("state: " + s);
      switch(s)
      {
         case RUNNABLE:
         case TIMED_WAITING: // aufgrund des Thread.sleep in run nötig
            return "running";
         case NEW:
            start();
         default:
            synchronized(this)
            {
               notify(); // Thread aus Wartepool geholt
            }
      }
      return "started";
   }
}
class Main
{
   public static void main(String[] args)
   {
      T t = new T();
      System.out.println(t.go()); // started
      try
      {
         Thread.sleep(500); // 0.5s
      }
      catch(InterruptedException e) 
      {
      }
      System.out.println(t.go()); // running
      try
      {
         Thread.sleep(1000); // 1s
      }
      catch(InterruptedException e) 
      {
      }
      System.out.println(t.go()); // started
   }
}

Funktioniert das so richtig?

Oder muss ich gar nicht mit wait arbeiten? Könnte ich statt dessen den Thread tatsächlich mit new neu starten?

class T extends Thread
{
   public void run()
   {
      // Hier irgendwelche Aktionen:
      System.out.println("run");
      try
      {
         Thread.sleep(1000); // 1s
      }
      catch(InterruptedException e) 
      {
      }
   }
}
class Wrapper
{
   private T t = new T();
   String go()
   {
      Thread.State s = t.getState();
      System.out.println("state: " + s);
      switch(s)
      {
         case RUNNABLE:
         case TIMED_WAITING: // aufgrund des Thread.sleep in run nötig
            return "running";
         default:
            t = new T();
         case NEW:
            t.start();
      }
      return "started";
   }
}
class Main
{
   public static void main(String[] args)
   {
      Wrapper w = new Wrapper();
      System.out.println(w.go()); // started
      try
      {
         Thread.sleep(500); // 0.5s
      }
      catch(InterruptedException e) 
      {
      }
      System.out.println(w.go()); // running
      try
      {
         Thread.sleep(1000); // 1s
      }
      catch(InterruptedException e) 
      {
      }
      System.out.println(w.go()); // started
   }
}

Ist es so vielleicht besser?

 

[Fansana]

Die Frage ist musst du überhaupt Threads benutzen?
Ich meine wenn ich das richtig verstanden habe kannst du doch auch einen einzigen Thread kontinuirlich laufen lassen. Dieser geht dann hin und ruft die nötigen Methoden auf.
Threads zu starten und danach wieder zu restarten ist doch unnötige Arbeit.
Setze den Thread doch einfach in seinen Ausgangs Zustand zurück.
Also eine Art Loop die immer wieder durchläuft.

 

[Joose]

Darum vermute ich, dass Instanzen von Aktionen-Klassen in eigenen Threads ablaufen. Da man Aktionen sicherlich immer wieder anstoßen kann, vermute ich, dass die Threads "restartable" sein müssen.

Ich nehme an solche "Aktionen" werden immer neu erstellt und dann entsprechend in einem laufenden Thread durchgeführt oder sie starten jeweils ihren eigenen Thread.

Ansonsten kannst du natürlich direkt beim User der den Code gepostet hat nachfragen wie dieser zu verstehen ist (am Besten im Thread dessen Link du gepostst hast).

 

[minzee]

Die Frage ist musst du überhaupt Threads benutzen?

Ohne Threads wäre es mir natürlich am liebsten. Aber wie würde dann so ein Programm aussehen?

 

[Fansana]

Naja Thread musst du eigentlich nur benutzen wenn du 2 sachen gleichzeitig ausführen willst.
Zum Beispiel ein Thread zum Laden von Bildern und der andere zum darstellen de fortschrittes.
(Hab ich zumindest in meinem Game so gemacht)

Was möchtest du denn mit deinen Threads alles machen?
Damit ich ein besseres Beispiel geben kann?

 

[minzee]

Es geht um dieses RUNNING. Wenn ein Knoten den Status eines Kind-Knotens abfragt, kann es auch ein RUNNING zurück erhalten. Das kommt, wenn der Kind-Knoten noch dabei ist, eine bestimmte Aktion auszuführen - wenn er also noch beschäftigt ist. Das würde ich gerne irgendwie implementieren.

 

[Joose]

Was ich rauslesen kann aus den Informationen ist:
Du willst das Parent und Kind gleichzeitig etwas machen können -> das heißt du musst mit Threads arbeiten.

Definiere dir ein Enum mit möglichen Werten die den Status angeben können. Zum Beispiel: CREATED, STARTED, RUNNING, WAITING, PAUSED, CLEANING, FINISHED, .....
Dazu noch ein weiteres mit möglichen Ergebniswerten. Zum Beispiel: OK, NOTOK, SUCCESS, ERROR, SUCCESS_WITH_IGNORED_ERROR, ....

Jetzt könntest du eine abstrakte Klasse (implementiert das Runnable Interface, die run Methode wird als abstrakt definiert) definieren mit 2 Attributen: status und result
Zu diesen Attributen die entsprechenden getter (public) und setter (protected) Methoden definieren.

In jeder Ableitung dieser Klasse muss nun die "run" Methode implementiert werden und in dieser Methode kannst du dann "status" und "result" setzen wie es benötigt wird.
Über die entsprechenden getter kannst du diese dann Abfragen.

 

[minzee]

Also so ähnlich wie meine beiden Varianten in Beitrag #3? Die liefern halt momentan nur die Stati RUNNING oder STARTED als Strings zurück.

 

[Joose]

Ja so in etwa ... verwende halt statt den Strings Enums.
Das hat einerseits einen Performance Vorteil (int Vergleich vs. String Vergleich). Außerdem kannst du so auch größer/kleiner Vergleiche einsetzen (kann man zum Beispiel brauchen wenn du etwas machen willst solange der Thread nicht im Status "FINISHED" oder höher ist)

 

[minzee]

Welche der beiden Varianten von Eintrag #3 ist denn schöner? Variante 1 braucht nur 1 Klasse, läuft aber ewig. Variante 2 braucht 2 Klassen, der Thread terminiert aber immer. Bei 1000 Aktionen ist also vermutlich bei Variante 1 weniger zu programmieren, aber es sind halt mit Fortlauf des Spiels immer mehr Threads im Status RUNNING oder WAITING. Oder gibt es vielleicht noch eine bessere, dritte Variante?