public static interface myrunnable extends Runnable{
public Object getValue();
}
Code:
public class Test {
public void methode1(){
class Thread1 implements myrunnable{
private String abc;
public void run(){
// do something with abc
}
public String getValue(){
return abc;
}
};
class Thread2 implements myrunnable{
private String def;
public void run(){
// do something with def
}
public String getValue(){
return def;
}
};
[Thread1 laufen lassen]...
[Thread2 laufen lassen]...
class Thread3 implements myrunnable{
private String ghi;
public void run(){
String t3_abc = Thread1.getValue(); // mit Hilfe von getValue() auf das Ergebnis von Thread1 zugreifen
String t3_def = Thread2.getValue(); // mit Hilfe von getValue() auf das Ergebnis von Thread2 zugreifen
}
public String getValue(){
return ghi;
}
};
[Thread3 laufen lassen]...
}
}
Ich hab noch kaum Erfahrung mit Threads. Was ich machen möchte ist folgendes: Ich muss auf Ergebnisse zugreifen, die innerhalb eines Threads "berechnet" werden. Dazu hab ich mir ein neues Interface definiert, das Runnable um die Methode getValue erweitert. Soweit so gut.
Probleme hab ich zum einen die Threads laufen zu lassen, vielleicht kann mir hier jmd einen Tip geben?
Zum anderen weiss ich nicht wie ich innerhalb von Thread3 auf die getValue() Methoden von Thread1 und Thread2 zugreifen kann.
IReturnRunnable my1 = new Thread2(); //Thread2 muss IReturnRunnable implementieren und nicht myrunnable
Thread t1 = new Thread(my1);
t1.start();
Zum Holen von Werten aus Thread3 müssen die Instanzen von Thread1 und Thread2 der Instanz von Thread3 bekannt sein.
Zum Beispiel über den Konstruktor:
Code:
class Thread3 implements myrunnable{
private String ghi;
private Thread1 t1;
private Thread2 t2;
public Thread3 (Thread2 t2, Thread1 t1) {
this.t1 = t1;
this.t2 = t2;
}
public void run(){
String t3_abc = t1.getValue(); // mit Hilfe von getValue() auf das Ergebnis von Thread1 zugreifen
String t3_def = t2.getValue(); // mit Hilfe von getValue() auf das Ergebnis von Thread2 zugreifen
}
public String getValue(){
return ghi;
}
};
Allerdings können Probleme mit der Synchronisation auftreten (sehr schwierig, die zu reproduzieren/finden)...
So kann es z.B. sein dass Thread3 als erstes startet und auch fertig wird => Thread2 und Thread1 haben noch keine Ergebnisse produziert => Problem :wink:
Eine Lösung fällt mir auf Anhieb nicht ein (ausser evtl. auf die Beendigung von Thread1 und Thread2 zu warten).
Da ist wohl meine Benennung der Instanzen nicht ganz glücklich gewesen
Es dürfen keine Objekte vom Typ Thread übergeben werden sondern Objekte vom Typ Thread1 und Thread2.
also so etwa:
Code:
Thread1 myThread1 = new Thread1();
Thread t1 = new Thread(myThread1);
t1.start();
Thread2 myThread2 = new Thread2();
Thread t2 = new Thread(myThread2);
t2.start();
Thread2 myThread3 = new Thread3(myThread1, myThread2);
Thread t3 = new Thread(myThread3);
t3.start();
