Threads

[fighter]

Es geht um die Realisierung eines grundlegenden Thread-Mechanismus, den ich noch nicht ganz verstehe :

public void run(){
  tuetwas(); 
  try{
    sleep(1000);
  } catch(InterruptedException e){}
}

Beim Start des jeweiligen Threads , wird tuetwas() ausgeführt und durch sleep(1000) "ruht" der Thread eine Sekunde lang. Sollte tueetwas() dann jedoch nicht jede weitere Sekunde ausgeführt werden ? Wie schaffe ich es , dass ein Befehl in regelmäßigen Abständen ausgeführt wird ?
Und eine weitere Frage : Wie gelingt eine run-Methode , in der zwei Befehle in zwei jeweils unterschiedlichen Zeitabständen aufgerufen werden ?

 

[InfectedBytes]

Man will ja nicht immer etwas unendlich oft in einem Thread machen, manchmal möchte man nur eine sehr rechenintensive Aufgabe parallel lösen, daher wird eben nur die run-Methode separat aufgerufen. Wenn du den Inhalt wiederholen willst, musst du eben eine Schleife darin nutzen. Am besten mit einer Abbrufbedingung

public void run() {
  while(shouldRun) {
    tuEtwas();
    //sleep
  }
}

Und für dein zweites Problem könntest du z.b. zwei Threads nutzen, die jeweils unterschiedlich lange wartezeiten haben.

 

[Varthor]

Vielleicht noch zum besseren Verständnis. Bei der späteren Thread Behandlung kannst du noch zwischen einer aktiven und einer passiven Klasse unterscheiden.
Synchronized, wait, notfiy Aufrufe werden normalerweise in der passiven Klasse geregelt und die aktive Klasse ( der eigentliche Thread) ist ein Dauerläufer. Die Schleife wäre dann

public void run()
{
   while(true)
   {
    tueetwas()
   }
}

Wenn du möchtest das der Thread "sich selbst steuert" musst du, wie Infectedbytes sagte, ihm das vorgeben, z.B.:

public CounterThread extends Thread
{
      integer counter;

      public CounterThread()
      {
      counter = 0;
      }

    public void run()
    {
    while(counter < 10)
    {
     try {
         counter++;
         sleep(1000);
      }
      catch(InterruptedException e)
      {
      } 
     
    }
}

 

[Joose]

Die Schleife wäre dann

public void run()
{
   while(true)
   {
    tueetwas()
   }
}

Bitte nicht die "while(true)" Schleifen verwenden! Diese Variante ist einfach eine schlechte Wahl und unschön.
Immer eine passende Abbruchbedingung verwenden!

(Auch wenn es nur ein Beispiel war, einfach eine erfinden )

 

[Varthor]

Hey Joose,

danke für die Anmerkung. Leider reichen meine Java Kenntnisse dann doch nicht so weit das ich mir in dies für Szenarien ohne klare Bedingungen vorstellen kann. Könntest du mir ein Beispiel geben?

Beispielsweise wenn ein Thread bei einem Server auf den InputStream wartet, oder eins der bekanntesten Beispiele: Autos (threads) warten an einer Ampel bis diese umschaltet und fahren dann weiter. Würdest du das über Flags regeln?

Dann wäre die Abbruchbedingung (?):

while(ampel==gruen)
{
tueetwas();
}

Wo liegt dann der Vorteil gegenüber einer while(true) Schleife?

Grüße
Varthor

 

[nvidia]

[...]Immer eine passende Abbruchbedingung verwenden! [...]

Die einfachste Möglichkeit wäre (in der korrekten Verwendung):

public static void main(String... args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(!Thread.currentThread().isInterrupted()) {
                    try{
                        Thread.sleep(3000);
                    } catch(InterruptedException e) {
                        e.printStackTrace();
                        Thread.currentThread().interrupt();
                    }
                }
            }
        });
    }

@Rest
Und für in zeitlich äquidistanten wiederkehrende Aufgaben könnte der TimerTask hilfreich sein. Aber das macht man heute nicht mehr händisch sondern delegiert die Erstellung an einen ScheduledExecutorService. Infos dazu z.B. unter ScheduledExecutorService | tutorials.jenkov.com

 

[VfL_Freak]

Moin,

while(ampel==gruen)
{
    tueetwas();
}

Wo liegt dann der Vorteil gegenüber einer while(true) Schleife?

Wenn dies ein gültiger Vergleich ist, wäre es eine Möglichkeit!

Der Nachteil von "while(true)" ist ganz einfach der, dass es eine Endlosschleife ist, die á priori erstmal nicht abgebrochen wird, es sein denn dass Du innerhalb der Schleife unter irgendeiner Bedingung gezielt ein "break" setzt!
Nur ist es dann sicherlich besser und sicherer diese Bedingung auch gleich als bedingung des Schleifenablaufes zu nehmen !

Gruß Klaus