Methoden Thread Schleife Status

[diabolik]

Hallo,

mal wieder stehe ich vor einem Problem, dass ich auf einen schlechten Code meinerseits zurückführe. Jedoch benötige ich nen Denkanstoss, wie ich aus dieser Einbahnstrasse wieder herauskommen...

Folgendes Szenario:

Ich habe einen Thread:

public class WorkerThread extends Thread{
    private final static int                        NOT_READY_FOR_OPERATIONS = 0;
    private final static int                        GOING_TO_BE_READY_FOR_OPERATIONS = 1;
    private final static int                        READY_FOR_OPERATIONS = 2;
    private final static int                        NOT_CONNECTED_TO_ROUTER = 3;
    private final static int                        WAITING_FOR_CONNECTION = 4;
    private final static int                        CONNECTED = 5;

    private int                                       requestState = 0;
    
    //[...] und so weiter
   
}

In diesem rufe ich nun, je nach Status (wird über die Konstanten dargestellt), Funktionen auf.

public void run(){
        
             try{
                       // Arbeitsschritte
                       //
                       switch(requestState){

                           case NOT_READY_FOR_OPERATIONS:
                                doThis();
                                break;

                           case GOING_TO_BE_READY_FOR_OPERATIONS:
                               doThat();
                                break;

                           case READY_FOR_OPERATIONS:
                                doSomethingElse();
                                break;

                           case WAITING_CONNECTION:
                                doWhatEver();
                                break;
                    }

                    Thread.sleep(100);
           
               }catch(Exception e){
                // Meldung
              }
        }

In den Funktionen wird der Status, nach deren Abarbeitung, auf den nächsten Wert gesetzt.

private void doThis(){
      // es passiert etwas
      // [...]
       
      // Bedingung prüfen
      if(Bedigung == true){
             requestState = READY_FOR_OPERATIONS;
      }
}

Nun habe ich aber das Gefühl, dass sich die Dinge hier manchmal überschlagen. Ich habe mir mal während der Laufzeit den requestState anzeigen lassen und die erwartetend Werte stimmen manchmal nicht mit den tatsächlichen überein.

Daher glaube ich, dass mein Code hier nicht gut ist.

Hat jemand einen Vorschlag, wie ich es besser machen kann?

Wichtig ist, dass der Thread immer wieder in Schleife läuft bis, die nächste Bedingung, passend zum aktuellen requestState, erfüllt ist. Das funktioniert hier ja auch generell, aber ich habe das Gefühl, dass es dennoch kein stabiler Code ist ...

 

[Gast2]

Wenn ich das richtig verstehe ist das eine State Machine welche in einem separaten Thread läuft.

Finde die Implementierung mittels switch statement nicht so schön da sie sehr schnell unübersichtlich wird.

Vielleicht wäre das State Muster was für dich!

 

[diabolik]

Wenn ich das richtig verstehe ist das eine State Machine welche in einem separaten Thread läuft.

Finde die Implementierung mittels switch statement nicht so schön da sie sehr schnell unübersichtlich wird.

Vielleicht wäre das State Muster was für dich!

State Muster? Das höre ich heute zum ersten mal. Hast Du da ein Beispiel?

 

[SlaterB]

Das State Design Pattern (Zustand Entwurfsmuster)

edit:
allerdings dort nicht unbedingt besser umgesetzt als dein switch, da muss kappesf vielleicht doch noch was liefern

 

[Gast2]

Ich find die Definition aus Entwurfsmuster von Kopf bis Fuß recht gut erläutert. Da sind gegen Ende des Kapitels auch noch Tipps was man im RealLife dann anders macht (Das Beispiel is ja schon etwas vereinfacht).

Dort wird alles mittels State Klassen gehandelt. Ist recht anschaulich. Kannst ja mal nachschauen obs nicht in der Vorschau unter GoogleBooks sogar drin ist!

 

[parabool]

Ich schätze, das du für jeden State einen neuen Thread startest? Könnte problematisch sein.
Versuche mal folgendes:

while(requestState!=-1)
{
    switch(requestState)
   {
       case NOT_READY_FOR_OPERATIONS:
               doThis();
               break;
               ...
   }
}

//End

requestState = -1 ist sozusagen der Ausstieg.

(Ansonsten wäre natürlich das state-Pattern ganz gut)

 

[Andi_CH]

switch case statements sind nur die nicht OO Umsetzung eines Problemes - ob du nun switch case schreibst oder das eine Stateobjekt durch ein anderes ersetzt ist nicht so wichtig.
(Ich persönlich mag beide Varianten gleich)

Ich bin überzeugt, dass dein Problem ein anderes ist.

Das ein Wert nicht den Tatsachen entspricht gibt es schlicht nicht - ein Wert ist eine Tatsache.

Wenn es nur ein Thread ist, hilft dir der Debugger weiter (doof ist eben, dass die anderen Threads weiterlaufen während der eine an einem Breakpoint hängt)

Ansonsten hilft nur exzessives logging - also sehr viele sysout - Zeilen (am Besten in ein Logfile) und dann analsysieren.

Aufgrund deines Minicodes ist es kaum möglich eine Aussage zu machen.

(Ach: hast du alle Breaks drin? da bin ich doch mehr als einmal auf die Schnauze geflogen ;-) )

@parabool: Hab ich was übersehen? Wo werden Threads gestartet?

 

[parabool]

Wo werden Threads gestartet?

Diese Vermutung ergibt sich aus dem geposteten Code: Das switch-case - Konstrukt
muss wiederholt durchlaufen werden um von einen zum nächsten State zu gelangen.

diabolik: dass der Thread immer wieder in Schleife läuft

Könnte natürlich sein, das in der Schleife immer nur die run-Methode aufgerufen, der Thread also nicht gestartet wird. Aber dann gäbe es nicht das beschriebene Problem...


Schade eigentlich das man oft nicht erfährt wie das Problem gelöst wurde.