# While-Schleife nach 10 sekunden abbrechen.



## sunnyfriday1 (31. Aug 2008)

Hallo,

Ich habe folgendes Problem:

Ich habe einen Thread. In der run() Methode habe ich eine whileschleife die nach 3 Zuständen pollt, bis ich den zustand setzte.

Ich möchte aber das die while- schleife max. 10 sekunden nach den zuständen pollt. Wenn nach 10 sekunden kein definierter zustand erkannt wird, dann whileschleife verlassen(timeout). 

Hat jemand ne idee?


```
class MyThrad extends Thread {

 int zustand;

 public void run(){


       while(!isInterrupted()){
  
            if(zustand ==1) System.out println("zustand1");
            if(zustand ==2) System.out println("zustand2");
            if(zustand ==3) System.out println("zustand3");

       }

 }

  setzustand(int zustand){

   this.zustand = zustand;

  }

}
```

danke  sunny


----------



## SlaterB (31. Aug 2008)

deine jetzige Schleife sorgt für 100% CPU lasst,
reicht es nicht, < 100 mal pro Sekunde den Wert zu prüfen statt 1 Mio. mal oder noch öfter?

von außen kannst du die Schleife nicht abbrechen,
aber du kannst die while-Bedingung ändern, Zeitmessung ist dir bekannt?


----------



## Marco13 (31. Aug 2008)

'n Timer vielleicht - aber wenn's eh schon ein eigener Thread ist, tut's wohl schon sowas wie

```
public void run(){

       long before =System.currentTimeMillis();
       while(!isInterrupted() && System.currentTimeMillis() < before + 10000){
 
            if(zustand ==1) System.out println("zustand1");
            if(zustand ==2) System.out println("zustand2");
            if(zustand ==3) System.out println("zustand3");

       }

}
```

EDIT: Ja, das ist häßlich - aus dem Grund, den SlaterB schon genannt hat: Es frißt Rechenleistung. Mit wait(timeout) und notfy() im setState wär's natürlich schöner, aber danach hast du ja nicht gefragt  :bae:


----------



## Guest (31. Aug 2008)

Könnte das vielleicht helfen?

```
class MyThrad extends Thread {

 int zustand;

 public void run(){
       //Endzeitpunkt des Pollens festlegen, aktuelle Zeit + 10 Sekunden
       long endZeitpunkt = System.currentTimeInMillis()+10000;
       //zusätzlich abfragen ob die 10 Sekunden nicht schon rum sind
       while(!isInterrupted() && endZeitpunkt >= System.currentTimeInMillis()){
  
            if(zustand ==1) System.out println("zustand1");
            if(zustand ==2) System.out println("zustand2");
            if(zustand ==3) System.out println("zustand3");

       }

 }

  setzustand(int zustand){

   this.zustand = zustand;

  }

}
```


----------



## Gast (31. Aug 2008)

Gegen das ständige Pollen, könnte auch eine Lösung nach dem Observer-Pattern angestrebt werden.


----------



## xysawq (1. Sep 2008)

Mach nen Timer der ohne delay gestartet wird und die run()-Methode mit while-Schleife startet, die solange läuft wie eine boolean-Variable true ist.

Nach einer festgelegten Zeit (z.B. 10 Sekunden) startet dr Timer wieder und setzt die boolean-Variable auf false und wird beendet.


```
class MyThread extends TimerTask
{
	int zustand;
	Timer timer = new Timer();
	boolean run = false;
	
	public void start()
	{
		timer.scheduleAtFixedRate(this, 0, 10000);
	}

	public void run()
	{
		if(run)
		{
			run = false;
			timer.cancel();
		}
		else
		{
			run = true;
			work();
		}
	}
	
	private void work()
	{
		while(run)
		{	 
			if(zustand ==1) System.out println("zustand1");
			if(zustand ==2) System.out println("zustand2");
			if(zustand ==3) System.out println("zustand3");
		}
	}

	public void setzustand(int zustand)
	{
	   this.zustand = zustand;
	}
}
```

So zum Beispiel.


----------



## Marco13 (1. Sep 2008)

Ja, nachdem so viele "so-kann-mans-machen-sollte-man-aber-nicht"-Lösungen gepostet wurden, das ganze nochmal mit wait&notify...

```
// For [url]http://www.java-forum.org/de/viewtopic.php?t=74209&highlight=[/url]


class WaitingThread extends Thread
{
    public static void main(String args[])
    {
        WaitingThread wt = new WaitingThread();
        wt.start();

        setZustandAfter(wt, 0, 1000); // Wartet weiter
        setZustandAfter(wt, 0, 3000); // Wartet weiter
        setZustandAfter(wt, 2, 5000); // Beendet


        wt = new WaitingThread();
        wt.start();
        // warten bis Timeout
    }

    private static void setZustandAfter(final WaitingThread wt, final int zustand, final int delay)
    {
        Thread t = new Thread(new Runnable()
        {
            public void run()
            {
                try
                {
                    Thread.sleep(delay);
                }
                catch (InterruptedException e)
                {
                }
                wt.setZustand(zustand);
            }
        });
        t.start();
    }




    private int zustand;

    public void run()
    {
        long start = System.currentTimeMillis();
        long end = start + 10000;

        while (zustand == 0)
        {
            long timeout = end - System.currentTimeMillis();
            if (timeout <= 0)
            {
                break;
            }
            synchronized (this)
            {
                if(zustand == 0) System.out.println("zustand0");
                if(zustand == 1) { System.out.println("zustand1"); break; }
                if(zustand == 2) { System.out.println("zustand2"); break; }
                if(zustand == 3) { System.out.println("zustand3"); break; }

                try
                {
                    System.out.println("Waiting for less than "+timeout+" ms");
                    wait(timeout);
                }
                catch (InterruptedException e)
                {
                    System.err.println("Interrupted!");
                    return;
                }

            }
        }
        System.out.println("Finished waiting after "+(System.currentTimeMillis()-start)+" ms, zustand "+zustand);
    }

    synchronized void setZustand(int zustand)
    {
        this.zustand = zustand;
        notify();
    }

}
```

Kann man immernoch aufräumen, aber das Prinzip dürfte so passen....


----------



## sunnyfriday (1. Sep 2008)

Was spricht eigentlich gegen diese Lösung??
Ich wollte doch nur dass mein thread einfach nur 10 sekunden pollt. Und wenn er nichts gefunden hat, dann verabschiedet er sich einfach.
Die anderen lösungen verwirren mich total... ;-)


```
class MyThrad extends Thread { 

int zustand; 

public void run(){ 
       //Endzeitpunkt des Pollens festlegen, aktuelle Zeit + 10 Sekunden 
       long endZeitpunkt = System.currentTimeInMillis()+10000; 
       //zusätzlich abfragen ob die 10 Sekunden nicht schon rum sind 
       while(!isInterrupted() && endZeitpunkt >= System.currentTimeInMillis()){ 
  
            if(zustand ==1) System.out println("zustand1"); 
            if(zustand ==2) System.out println("zustand2"); 
            if(zustand ==3) System.out println("zustand3"); 

       } 

} 

  setzustand(int zustand){ 

   this.zustand = zustand; 

  } 

}
```


----------



## SlaterB (1. Sep 2008)

SlaterB hat gesagt.:
			
		

> deine jetzige Schleife sorgt für 100% CPU lasst,
> reicht es nicht, < 100 mal pro Sekunde den Wert zu prüfen statt 1 Mio. mal oder noch öfter?


----------



## sunnyfriday (1. Sep 2008)

hallo ;-)


und so?
	
	
	
	





```
class MyThrad extends Thread { 

int zustand; 

public void run(){ 
       //Endzeitpunkt des Pollens festlegen, aktuelle Zeit + 10 Sekunden 
       long endZeitpunkt = System.currentTimeInMillis()+10000; 
       //zusätzlich abfragen ob die 10 Sekunden nicht schon rum sind 
       while(!isInterrupted() && endZeitpunkt >= System.currentTimeInMillis()){ 
  
            if(zustand ==1) System.out println("zustand1"); 
            if(zustand ==2) System.out println("zustand2"); 
            if(zustand ==3) System.out println("zustand3"); 
        
        sleep(100); !!!!!

       } 

} 

  setzustand(int zustand){ 

   this.zustand = zustand; 

  } 

}
```


----------



## SlaterB (1. Sep 2008)

sleep könnte eine leere Methode sein, 
aber ich vertraue mal darauf, dass das so deutlich besser ist 

zu bedenken:
wenn du Pech hast, dauert die Schleife so 10,099 Sekunden


----------



## sunnyfriday (1. Sep 2008)

> zu bedenken:
> wenn du Pech hast, dauert die Schleife so 10,099 Sekunden



der war gut ;-)


----------



## xysawq (1. Sep 2008)

Übrigens: bei meiner vorher geposteten Variante brauchst du nicht bei jedem while-Durchlauf die Zeit prüfen...

Der Timer macht das voll-automatisch und braucht auch exakt 10000 Millisekunden und nicht 10099!

Du erstellt nicht mehrere Threads oder machst irgendwelche anderen Faxen, sonder du startest den Timer und der Rest läuft von selbst, beendet sich von selbst und du kannst den ganzen Spaß auch immer und immer wieder neu starten.

Bezüglich der CPU-Last kannst du natürlich auch noch ein Thread.sleep(1); einbauen, dann wird eben nur jede Millisekunde geschaut, aber nicht aller 100.

Bei mir sind die Timer immer verbaut, wenn ich was machen möchte, was eine bestimmte Zeit dauert oder in bestimmten Intervallen stattfinden soll.


----------



## sunnyfriday (1. Sep 2008)

hallo,

danke für deine Erläuterung...
Klingt natürlich auch gut... 

danke


----------



## Marco13 (1. Sep 2008)

Ja. Ich hab auch immer meinen Mail-Client offen, und klick' alle 100 Millisekunden auf "Neue Nachrichten abrufen"....


----------



## sunnyfriday (2. Sep 2008)

hallo,

ich habe ein weiteres Problem bekommen.
und zwar:

Die Objekte zustand1, zustand2, zustand3 implementieren alle ein Interface mit den Methoden read() und write()

Ich habe die read() und write() Aktionen im einer Funkton work() ausgelagert (siehe code).

Wieso funktioniert das nicht so wie ich es in work() gemacht habe?




```
class MyThrad extends Thread {

int zustand;

public void run(){


       while(!isInterrupted()){
 
            if(zustand ==1) {
            
                  work(new zustand1());
            }

           if(zustand ==2) {
            
                  work(new zustand2());
            }

          if(zustand ==3) {
            
                 work(new zustand3());
            }

       }

}



public void work(Object zustand){

   if( zustand isinstanceof zustand1){
      zustand1 neuzustand = new zustand1();

    }

   if( zustand isinstanceof zustand2){
      zustand2 neuzustand = new zustan2();

    }

   if( zustand isinstanceof zustand3){
      zustand3 neuzustand = new zustan3();

    }


    zustand.read();
    zustand.write();


}





  setzustand(int zustand){

   this.zustand = zustand;

  }

}
```


----------



## Murray (2. Sep 2008)

Wozu erzeugst Du in der work-Methode die neuen Instanzen, mit denen Du dann nichts machst?


----------



## xysawq (2. Sep 2008)

Du erzeugst ziemlich sinnlos Instanzen von den Zuständen. Es währe einfacher in der while-Schleife zu schauen, ob sich "int zustand" verändert hat, zudem initialisierst du diese Variable nicht (also "int zustand = 0"). So hast du nur den Namen reserviert und das Programm weiß garnicht was es jetzt mit 1, 2 oder 3 vergleichen soll.

Also:

```
class MyThrad extends Thread
{
	int zustand = 0;
	int alterZustand = 0;

	public void run()
	{
		while(!isInterrupted())
		{
			if(zustand != alterZustand)
			{
				alterZustand = zustand;
				work(zustand);
			}
		}
	}

	public void work(int neuerZustand)
	{
		if(neuerZustand == 1)
		{
			zustand1 neuzustand = new zustand1();
		}
		if(neuerZustand == 2)
		{
			zustand2 neuzustand = new zustand2();
		}
		if(neuerZustand == 3)
		{
			zustand3 neuzustand = new zustand3();
		}

		neuzustand.read();
		neuzustand.write();
	}

	setzustand(int zustand)
	{
		this.zustand = zustand;
	}
}
```


----------



## sunnyfriday (2. Sep 2008)

hallo,

wenn ich aber in work()

neuzustand.read();  aufrufe,

dann kommt die fehlermeldung "neuzustand kann nicht aufgelöst werden".


----------



## xysawq (2. Sep 2008)

Achja... ist ja auch klar ^^... die existiert ja nur in der IF-Schleife

Dann brauchst du ein Interface oder eine abstrakte Klasse (Interface finde ich besser), das die Methoden read() und write() vorschreibt und deine Zustand-Klassen implementieren dieses Interface, bekommen somit auch die Methoden, dann nur noch:


```
public void work(int neuerZustand)
   {
      ZustandInterface neuzustand = null;

      if(neuerZustand == 1)
      {
         neuzustand = new zustand1();
      }
      if(neuerZustand == 2)
      {
         neuzustand = new zustand2();
      }
      if(neuerZustand == 3)
      {
         neuzustand = new zustand3();
      }

      neuzustand.read();
      neuzustand.write();
   }
```

Und es geht


----------



## sunnyfriday (2. Sep 2008)

jap ;-) jetzt gehts !!! danke


----------

