Mit 2 Klassen auf selben Thread zugreifen

[tobi193]

Hallo,
ich habe ein vermutlich recht banales Problem, aber kann es auch mit Hilfe von Google nicht lösen.
Ich habe eine Klasse test und eine test2. In der Test wird erfolgreich auf den Thread steuern zugegriffen. Nun möchte ich aber in test2 Werte eingeben, die dann an den Thread gesendet werden und somit an test weitergegeben werden. Aber das klappt nicht.
Wie kann ich mit beiden auf das selbe Objekt zugreifen ? So erstelle ich ja für jede Klasse ein eigenes.

Das ganze sieht so aus:

  public class test {

    public static void main(String args[]) {
      steuern s;

      s = new steuern();
      s.start();
      
      while(s.getAktiv()){
        s.run();
        System.out.println(s.getQuer());
      }
    }
  }

  public class test2 {

    public static void main(String args[]) {
        steuern s;

      s = new steuern();
      s.start();
      for(int i = 1; i < 15; i++){
         s.setQuer(Tastatur.liesInt());
      }
    }
  }

class steuern extends Thread {

    private int quer;
    private boolean aktiv;
    
    public void run() {
       if(quer > 3){
        quer = quer + 5;
       }
    }
    
    public int getQuer(){
       return quer;
    }
    
    public void setQuer(int q){
       quer = q;
    }
    
    public boolean getAktiv(){
      return aktiv;
    }
}

Tastatur.liesInt() ist übrigens eine Klasse meiner Schule, die ließt einfach einen Int-Wert vom Nutzer aus.

Gruß tobi

Edit: Ups, falsches Forum.

 

[Dissi]

Hallo Tobi,
du hast hier mehrere Probleme.

Zum einen, du kannst nur eine "Main" Methode starten und müsstest von dieser aus die andere starten. Zudem erstellst du von deiner Klasse steuern (die Groß geschrieben werden muss) 2 extra Instanzen und haben somit keinen Bezug zueinader.

Generell gilt aber, dass wenn du von mehreren Instanzen auf den gleichen Thread zugreifen willst, solltest du dir "synchronized Threads" anschauen.

Java Quick Reference - Threads - synchronized keyword

Leider auf Englisch.
Google einfach mal, gibts sicher auch auf Deutsch.

MFG

 

[tobi193]

Hallo,
also inzwischen hat sich das Problem etwas geändert, aber ich bekomme es noch immer nicht hin.
Ein Thread (zeit) wird in der Mainklasse (rechnen) initialisiert und gestartet. Dann zählt der Thread sekündlich eins höher. Nun kann ich ja problemlos über die get Methode die Zeit abrufen, aber ich möchte in der Hauptklasse ein Feld haben, welches ständig die aktuelle Zeit zeigt.

Wie kann ich also vom Thread aus in der Hauptklasse direkt in ein Textfeld schreiben ?

Mit den synchronized Threads habe ich mich schon beschäftigt, aber nichts erreicht.

public class zeit extends Thread{
  private int zeit;
  public void run(){
     zeit = 0;
     while(true){
         try{
           sleep(1000);
         }catch(InterruptedException e){
         }
         zeit++;
     }
  }  
  public String getZeit(){
    return zeit + "";
  }
    public void zuruecksetzen(){
    zeit = 0;
  }
}

public class rechnen extends JFrame{
...
 JLabel rechnung = new JLabel("");
 zeit z = new zeit();

...
   public rechnen(){
   super("Rechentest");
   this.setLayout(new GridLayout(5,1,5,5));
   this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   this.add(rechnung);
   ...
   }

  public static void main(String[] args) {
   rechnen bla = new rechnen();
  }
}

 

[Michael...]

Deine Klasse zeit (Klassennamen sollten mit einen Großbuchstaben beginnen) benötigt Zugriff auf das Label rechnung oder die Instanz von rechnen. Du musst also dem Thread das entsprechende Objekt übergeben (z.B. im Konstruktor oder per set()) dann kannst Inhalt des Labels in der while Schleife aktualisieren.
Gewöhnlich implementiert man das Interface Runnable anstatt von Thread zu erben.

 

[tobi193]

Also, ich habe mal so begonnen:
JLabel rechnung = new JLabel();
zeit z = new zeit(rechnung);


Und in der Zeit.java:

public zeit(JLabel rechnung){

}

Ich stehe grad auf dem Schlauch, wie geht es jetzt weiter ?

 

[Michael...]

public class zeit ...
    private JLabel label;
    ...
    public zeit(JLabel rechnung) {
        this.label = rechnung;
    }

    public void run() {
        ...
        while(true) {
            ...
            label.setText(++zeit);
        }
    }...

Und was mir gerade auffällt: eine Variable (zeit) genauso wie eine Klasse (zeit) zu benennen ist nicht so geschickt, erst Recht wenn man entgegen der Kovention Klassennamen klein schreibt.

 

[Dissi]

schreib dir einen Setter (in der GUI Klasse) für den Text auf dem Label

setTextOnLabel(String anzeigeText){label.setText(anzeigeText)}

Diese Methode kannst du dann in deiner zählschleife aufrufen und den wert reinschreiben. Dazu müsstest du eine Referenz von dem GUI an das Model geben. Find das alles zwar bisschen unschön, aber sollte deinem Zweck gerecht werden. Bevor du deine Codesmells nich refactort hast, sag ich gar nix mehr

 

[tobi193]

Vielen Dank für eure Hilfe, jetzt läuft das ganze soweit.
Aber nun bin ich schon am nächsten Problem. Ich will den Thread anhalten und später wieder weiterlaufen lassen.
Mit interrupt hat das so gar nicht funktioniert, also habe ich mir 2 Methoden geschrieben:

...
  private boolean laufen;
...
 public void run(){
     zeit = 0;
     do{
         try{
           sleep(1000);
         }catch(InterruptedException e){
         }
         zeit++;
         if(laufen){
           label.setText(" Zeit: " + zeit);
         }
     }while(laufen);
  }
...  
  public void anhalten(){
    laufen = false;
  }
  public void weitermachen(){
    laufen = true;
  }

Das Anhalten klappt prima. Nur weitermachen will er nicht.
Gruß tobi

 

[Michael...]

sobald "laufen" auf false gesetzt wird, läuft der Thread aus der while Schleife und stirbt.
Von was hängt es denn ab, ob die Zeitanzeige aktualisiert werden soll oder nicht, die Zeit selbst soll weiter laufen, wenn ich das richtig deute??

 

[tobi193]

Naja, in dem Fall soll die Zeit nicht unbedingt weiterlaufen. Danach fängt der Zähler wieder bei 0 an.
Aber ich würde für zukünftige Projekte schon gerne mal wissen wie man korrekt stoppen und weiterlaufen lassen kann.

 

[Dissi]

So wie du, macht man es richtig : ) und bei google gibt es massig beispiele wie man threads nur anhält. Schau dir die Beispiele an und versuchs. Learning by doing!

 

[Michael...]

Wenn der Zähler sowieso wieder bei 0 anfangen soll, macht es eher Sinn einen neuen Thread zu starten, als einen bestehenden "am Leben" zu halten und später wieder weiterlaufen zu lassen.
Um einen Thread pausieren zu lassen, gibt es die Möglichkeit wait() an einem dem Thread bekannten Objekt aufzurufen. Das Objekt kann dann später per notify() bzw. notifyAll() den wartenden Thread wieder weiterlaufen lassen. Mit diesen Schlüsselwörtern sind sicherlich ein paar Bsp. zu finden.