# Zugriff auf Variable im Thread?



## flasher008 (14. Feb 2005)

Hi zusammen,

ich habe da ein Problem bezügl eines Threads;

Ich habe in einer Applikation einen Thread laufen, der in einer Endlos-Schleife prüft, ob ein Rechner am Leben ist.  Das ganze sieht in etwa wie folgt aus:


```
System.out.println("Rechner wird geprüft");

// Thread starten
check_host.start();

[...]weitere Befehle[...]
```

Wie ihr seht führe ich nach dem Aufruf des Threads weitere Befehle aus (wie z.B. den Inhalt einer Textbox ändern, etc.). Den Thread habe ich gestartet, damit das Programm nicht hängt, bis der Rechner sich meldet. Mein Problem nun:
Wie kann ich jetzt später herausfinden, ob der Rechner wieder am Leben ist!? Ich kann zwar direkt in dem Thread eine Meldung herausgeben, wenn der Rechner online ist, aber mein Haupt-Programm kriegt davon ja nichts mit...  Ich hoffe jemand hat da einen guten Lösungsansatz. Bei Bedarf kann ich auch genauere Codeschnippsel reinkopieren.


----------



## hugo (15. Feb 2005)

Was hälst du davon, eine Methode im Thread zu schreiben, mit der du die nötigen Werte auslesen kannst? Du musst nur aufpassen, dass du die Daten nicht abfragen willst, während ein Schreibvorgang stattfindet. --> Stichwort: synchronized.
Ansonsten funktioniert noch die Variante, dein Threadaufrufer mit dem Thread bekannt zu machen und dann den Thread veranlassen, eine Methode des Thread-Aufrufers aufzurufen.


----------



## flasher008 (15. Feb 2005)

Also das verstehe ich noch nicht ganz. Vielleicht kann mir jemand anhand meines Programms helfen; Hier meine Thread Klasse:


```
class PingThread extends Thread
{
 int m_TimeToSleep;
 String m_statusString = "E4589 no status";
 
 // Konstruktor
 PingThread(int pTimeToSleep)
 {
  m_TimeToSleep = pTimeToSleep;
 }
 
 public void run()
 {
  m_statusString = "PingThread Start";
  System.out.println("--- PingThread Start - m_statusString = " + m_statusString);

  while(isInterrupted()==false)
  {
   try
   {
    System.out.println("--- test" + m_statusString);
    sleep(m_TimeToSleep);
   }
   catch(InterruptedException e)  
   {}
  }

  System.out.println("Ende Thread.");
  m_statusString = "Ende Thread.";
 }
 
 public String getStatusString()
 {
  System.out.println( m_statusString );
  return m_statusString;
 }
 
}
```


Und hier jetzt die Methode in der ich die Instanz des Threads erzeuge und aufrufe:


```
exec_thread = new PingThread(1000);
  exec_thread.start();

  [...weitere Befehle...]
```

Wie kann ich es jetzt anstellen, dass mein Programm es mitbekommt, wenn der Thread erfolgreich den Rechner erreicht hat!?


----------



## hugo (15. Feb 2005)

hab ich dich richtig verstanden, dass der Thread eigentlich feritg ist, wenn er den Host erreicht hat?
Wenn das so ist, lass den Thread doch die Schleife beenden. Dann beendet sich auch der Thread, weil er ja an das Ende der run()-Methode kommt. Dann testest du, ob der thread noch lebt.

```
boolean erreicht = exec_thread.isAlive();
```
Wenn der Thread nicht mehr lebt, weißt du, das du am Ziel bist.

Eine andere Möglichkeit ist, dass du Thread im Konstruktor dein aufrufendes Objekt übergibst.
Dein Ping-Thread:

```
class PingThread extends Thread 
{ 
    int m_TimeToSleep; 
    String m_statusString = "E4589 no status"; 
    Aufrufer starter;

    // Konstruktor 
   PingThread(Aufrufer einAufrufer, int pTimeToSleep) 
   { 
      m_TimeToSleep = pTimeToSleep; 
      starter = einAufrufer;
   } 

   public void run() 
   { 
      // was auch immer drin steht
      if(zielerreicht)
      {
          starter.setStatus(true);
      }
   }
}
```

Dein Aufrufer:

```
class Aufrufer
{
  boolean erreichtZiel = false;  
 
  // Methode mit Aufruf des Thread
  void startThread()
  {
      // Thread starten
  }

  void setStatus(boolean status)
  {
     // Status setzen
     erreichtZiel = status;
  }
}
```
Und durch Abfrage deiner Variablen erreichtZiel kannst du prüfen, ob du da hingekommen bist, wo du wolltest
Zweite Variante ist aber nicht ganz so gut, da du die Thread-Klasse immer erst mit der anderen bekannt machen musst.

Deine Variante ist änhlich meiner Zweiten. Über den Aufruf exec_thread.getStatusString() erhälst du dann den jeweiligen Zustand.


----------

