Comment puis-je passer un paramètre à un Fil de Java?

Anonyme pour les classes de:

En réponse à la question édite ici est de savoir comment il fonctionne pour les classes

   final X parameter = ...; //the final is important
   Thread t = new Thread(new Runnable() {
       p = parameter;
       public void run() { 
         ...
       };
   t.start();

---

Nommé classes:

Vous avez une classe qui étend la classe Thread (ou implements Runnable) et un constructeur avec paramètres que vous souhaitez passer. Ensuite, lorsque vous créez le nouveau thread, vous devez passer dans les arguments, et puis commencer le fil, quelque chose comme ceci:

Thread t = new MyThread(args...);
t.start();

Exécutable est une bien meilleure solution que de Fil BTW. Donc je préfère:

   public class MyRunnable implements Runnable {
      private X parameter;
      public MyRunnable(X parameter) {
         this.parameter = parameter;
      }

      public void run() {
      }
   }
   Thread t = new Thread(new MyRunnable(parameter));
   t.start();

Cette réponse est fondamentalement la même que cette question similaire: Comment passer des paramètres à un objet Thread

Cette réponse arrive très tard, mais peut-être que quelqu'un va trouver utile. C'est sur la façon de passer un paramètre(s) à un Runnable sans même déclarer la classe nommée (très pratique pour inliners):

String someValue = "Just a demo, really...";
new Thread(new Runnable() {
    private String myParam;
    public Runnable init(String myParam) {
        this.myParam = myParam;
        return this;
    }
    @Override
    public void run() {
        System.out.println("This is called from another thread.");
        System.out.println(this.myParam);
    }
}.init(someValue)).start();

Bien sûr, vous pouvez reporter l'exécution de start à certains plus commode ou un moment approprié. Et il est à vous ce sera la signature de init méthode (ainsi, il peut prendre plus et/ou des arguments différents) et bien sûr son nom même, mais, fondamentalement, vous obtenez une idée.

En fait, il est aussi une autre façon de passer un paramètre à une classe anonyme, avec l'utilisation de l'initialiseur de blocs. Considérez ceci:

String someValue = "Another demo, no serious thing...";
int anotherValue = 42;

new Thread(new Runnable() {
    private String myParam;
    private int myOtherParam;
    {
        this.myParam = someValue;
        this.myOtherParam = anotherValue;
    }
    @Override
    public void run() {
        System.out.println("This comes from another thread.");
        System.out.println(this.myParam + ", " + this.myOtherParam);
    }
}).start();

Donc tout se passe à l'intérieur de l'initialiseur de bloc.

De créer un thread, vous avez l'habitude de créer votre propre implémentation de Runnable. Passer les paramètres au fil dans le constructeur de cette classe.

class MyThread implements Runnable{
   private int a;
   private String b;
   private double c;

   public MyThread(int a, String b, double c){
      this.a = a;
      this.b = b;
      this.c = c;
   }

   public void run(){
      doSomething(a, b, c);
   }
}

Soit écrire une classe qui implémente Runnable, et de transmettre ce que vous avez besoin dans un convenablement défini constructeur, ou d'écrire une classe qui étend la classe Thread avec un convenablement défini constructeur qui appelle super() avec les paramètres appropriés.

Paramètre, en passant par la start() et run() méthodes:

//Tester
public static void main(String... args) throws Exception {
    ThreadType2 t = new ThreadType2(new RunnableType2(){
        public void run(Object object) {
            System.out.println("Parameter="+object);
        }});
    t.start("the parameter");
}

//New class 1 of 2
public class ThreadType2 {
    final private Thread thread;
    private Object objectIn = null;
    ThreadType2(final RunnableType2 runnableType2) {
        thread = new Thread(new Runnable() {
            public void run() {
                runnableType2.run(objectIn);
            }});
    }
    public void start(final Object object) {
        this.objectIn = object;
        thread.start();
    }
    //If you want to do things like setDaemon(true); 
    public Thread getThread() {
        return thread;
    }
}

//New class 2 of 2
public interface RunnableType2 {
    public void run(Object object);
}

Dans Java 8, vous pouvez utiliser lambda expressions avec le La simultanéité de l'API & la ExecutorService comme un niveau plus élevé de remplacement pour travailler avec des fils directement:

newCachedThreadPool() Crée un pool de threads qui crée de nouveaux threads
au besoin, mais de réutilisation déjà construits fils quand ils sont
disponible. Ces piscines sont généralement d'améliorer les performances des programmes qui s'exécutent beaucoup de courte durée des tâches asynchrones.

    private static final ExecutorService executor = Executors.newCachedThreadPool();

    executor.submit(() -> {
        myFunction(myParam1, myParam2);
    });

Voir aussi executors la documentation javadoc.

Il existe un moyen simple de passer des paramètres dans runnables.
Code:

public void Function(final type variable) {
    Runnable runnable = new Runnable() {
        public void run() {
            //Code adding here...
        }
    };
    new Thread(runnable).start();
}

Spécialement pour Android

Pour rappel fins j'ai l'habitude de mettre en place mes propres générique Runnable avec un paramètre d'entrée(s):

public interface Runnable<TResult> {
    void run(TResult result);
}

Utilisation est simple:

myManager.doCallbackOperation(new Runnable<MyResult>() {
    @Override
    public void run(MyResult result) {
        //do something with the result
    }
});

Dans le gestionnaire:

public void doCallbackOperation(Runnable<MyResult> runnable) {
    new AsyncTask<Void, Void, MyResult>() {
        @Override
        protected MyResult doInBackground(Void... params) {
            //do background operation
            return new MyResult(); //return resulting object
        }

        @Override
        protected void onPostExecute(MyResult result) {
            //execute runnable passing the result when operation has finished
            runnable.run(result);
        }
    }.execute();
}

Créer une variable locale dans votre classe extends Thread ou implements Runnable.

public class Extractor extends Thread {
    public String webpage = "";
    public Extractor(String w){
        webpage = w;
    }
    public void setWebpage(String l){
        webpage = l;
    }

    @Override
    public void run() {//l is link
        System.out.println(webpage);
    }
    public String toString(){
        return "Page: "+webpage;
    }}

De cette façon, vous pouvez passer une variable lorsque vous l'exécutez.

Extractor e = new Extractor("www.google.com");
e.start();

La sortie:

"www.google.com"