Zugriff auf ein ausführbares Objekt per Thread?

Question

Mögliches Duplikat: need-help-returning-object-in-thread-run-method

Hallo. Ich habe eine Klasse, die runnable implementiert und ich habe eine Liste, die Threads speichert, die mit verschiedenen Objekten dieser Klasse instanziiert sind. Wie kann ich auf Eigenschaften von zugrunde liegenden Objekten zugreifen, wenn das Thread-Objekt sie ausführt? Hier ein Beispiel:

public class SO { 
    public static class TestRunnable implements Runnable { 
     public String foo = "hello"; 

     public void run() { 
      foo = "world"; 
     } 
    } 

    public static void main(String[] args) { 
     Thread t = new Thread(new TestRunnable()); 
     t.start(); 
     //How can I get the value of `foo` here? 
    } 
} 

Answer 1

Ich habe keine Art und Weise sehen, es zu tun in dem java.lang.Thread docs.

Meine beste Antwort ist dann, dass Sie wahrscheinlich List<Runnable> statt (oder zusätzlich) List<Thread> verwenden sollten. Oder vielleicht möchten Sie eine Art map Struktur, so dass Sie auf das Runnable vom Thread zugreifen können. (Zum Beispiel java.util.HashMap<java.lang.Thread, java.lang.Runnable>)

Answer 2

TestRunnable r = new TestRunnable(); 
Thread t = new Thread(r); 
t.start(); 
//there you need to wait until thread is finished, or just a simple Thread.sleep(1000); at this case 
System.out.println(r.foo); 

BTW, im realen Fall, dass Sie Callable und FutureTask

Answer 3

Dies ist zu verwenden, wie Sie dies direkt umsetzen können.

public static void main(String[] args) { 
    // Keep a reference to the runnable object for later ... 
    TestRunnable r = new TestRunnable(); 
    Thread t = new Thread(r); 
    t.start(); 
    // Wait until the child thread has finished 
    t.join(); 
    // Pull the result out of the runnable. 
    System.out.println(r.foo); 
} 

jedoch der moderne (weniger fehleranfällig) Weg, um diese Art der Sache zu tun ist, die auf höhere Ebene Concurrency Klassen in java.util.concurrent zu verwenden.

Answer 4

Wenn Sie den Wert eines asynchronen Berechnung zurückkehren möchten, schauen Sie sich aufrufbare und FutureTask:

FutureTask<String> task = new FutureTask(new Callable<String>() { 
    public String call() { 
     return "world"; 
    } 
}); 
new Thread(task).start(); 
String result = task.get(); 

Answer 5

Die Gleichzeitigkeit Bibliothek dies auch unterstützt. Hinweis: Wenn Sie Ihre Aufgabe eine Ausnahme auslöst, wird die Zukunft dieses halten und eine Verpackungs Ausnahme auslösen, wenn Sie anrufen get()

ExecutorService executor = Executors.newSingleThreadedExecutor(); 

Future<String> future = executor.submit(new Callable<String>() { 
    public String call() { 
     return "world"; 
    } 
}); 

String result = future.get(); 

Answer 6

ich im Allgemeinen denken, Sie können/sollten dies vermeiden zu tun, aber wenn Sie wirklich brauchen sollte es nicht so etwas wie MatrixFrogs Vorschlag funktionieren (ungetestet):

class RunnableReferencingThread extends Thread { 
    public final Runnable runnable; 
    public RunnableReferencingThread(Runnable r) { 
     this.runnable = r; 
     super(r); 
    } 
} 

?

Answer 7

Sie könnten Thread ableiten und die von Ihnen benötigte Methode hinzufügen. Sie müssen Ihre eigene Kopie des Ziels "Runnable" behalten und alle Thread-Konstruktoren, die Sie zum Erstellen des Threads verwenden, überschreiben, da einige Implementierungsdetails von Thread lästig sind.

Answer 8

Ich hatte das gleiche Problem. Hier ist meine Lösung:

public static class TestRunnable implements Runnable { 
    public String foo = "hello"; 

    public void run() { 
     foo = "world"; 
    } 

public static void main(String[] args) { 
    TestRunnable runobject = new TestRunnable(); 
    Thread t = new Thread(runobject); 
    runobject.foo; //The variable from runnable. hello; 
    t.start(); 
    runobject.foo; //The variable from runnable. world; 
} 

Answer 9

Wenn Ihr Thread-Zustandsinformationen hat, vergessen Runnable und einfach Thema erweitern, das Überschreiben der run-Methode.

Answer 10

Um ein konkretes Beispiel von Paul Crowley Lösung zu geben, ich denke, das ist, was er verspricht:

public class BackgroundJob<JOB extends Runnable> extends Thread { 

    private final JOB mJob; 

    public BackgroundJob(JOB job) { 
     super(job); 
     mJob = job; 
    } 

    public JOB getJob() { 
     return mJob; 
    } 

}