Comment accéder à un objet Runnable par Thread?

Question

Copie possible: need-help-returning-object-in-thread-run-method

Bonjour. J'ai une classe implémentant runnable et j'ai un List, stockant des Threads instanciés avec différents objets de cette classe. Comment puis-je accéder aux propriétés des objets sous-jacents compte tenu de l'objet thread qui les exécute? Voici un exemple:

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

Je ne vois aucune façon de le faire dans les java.lang.Thread docs. Ma meilleure réponse, alors, est que vous devriez probablement utiliser List<Runnable> au lieu de (ou en plus de) List<Thread>. Ou peut-être vous voulez une sorte de structure map afin que vous puissiez accéder à la Runnable à partir du Thread. (Par exemple, 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, en cas réel, vous devez utiliser Callable et FutureTask

Answer 3

Voici comment vous pouvez mettre en œuvre ce directement.

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); 
} 

Cependant, le moderne (moins sujette aux erreurs) façon de faire ce genre de chose est d'utiliser les classes de concurrence plus haut niveau dans java.util.concurrent.

Answer 4

Si vous voulez retourner la valeur d'un calcul asynchrone, regardez appelable et FutureTask:

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

Answer 5

La bibliothèque prend en charge ce bien concurrency. Remarque: Si votre tâche renvoie une exception, l'avenir tiendra cela et jeter une exception d'emballage lorsque vous appelez get()

ExecutorService executor = Executors.newSingleThreadedExecutor(); 

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

String result = future.get(); 

Answer 6

Je pense qu'en général, vous pouvez/devrait éviter de le faire, mais si vous avez vraiment besoin ne devrait-il pas quelque chose comme la suggestion de MatrixFrog travail (non testé):

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

?

Answer 7

Vous pouvez sous-classer Thread et ajouter la méthode dont vous avez besoin. Vous devrez conserver votre propre copie de la Runnable cible et remplacer tous les constructeurs de Thread que vous utilisez pour créer le Thread, à cause des détails d'implémentation ennuyeux de Thread.

Answer 8

J'ai eu le même problème. Voici ma solution:

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

Si votre fil contient des informations d'état, oublier Runnable et simplement étendre cette discussion, redéfinissant la méthode d'exécution.

Answer 10

Pour donner un exemple concret de la solution de Paul Crowley, je pense que c'est ce qu'il suggère:

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; 
    } 

}