Wie kann ich einen Parameter an einen Java-Thread übergeben?

Question

Kann mir jemand vorschlagen, wie ich einen Parameter an einen Thread übergeben kann?

Und wie funktioniert das bei anonymen Klassen?

Answer 1

Sie müssen den Parameter im Konstruktor an das Runnable-Objekt übergeben:

public class MyRunnable implements Runnable {

   public MyRunnable(Object parameter) {
       // store parameter for later user
   }

   public void run() {
   }
}

und rufen ihn so auf:

Runnable r = new MyRunnable(param_value);
new Thread(r).start();

Answer 2

Für anonyme Klassen:

Als Antwort auf die Frage "Editieren": So funktioniert es für anonyme Klassen

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

---

Benannte Klassen:

Sie haben eine Klasse, die Thread erweitert (oder Runnable implementiert) und einen Konstruktor mit den Parametern, die Sie übergeben möchten. Wenn Sie dann den neuen Thread erstellen, müssen Sie die Argumente übergeben und dann den Thread starten, etwa so:

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

Runnable ist im Übrigen eine viel bessere Lösung als Thread. Ich würde also bevorzugen:

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

Diese Antwort ist im Grunde die gleiche wie die ähnliche Frage: Wie man Parameter an ein Thread-Objekt übergibt

Answer 3

Über den Konstruktor einer Runnable- oder Thread-Klasse

class MyThread extends Thread {

    private String to;

    public MyThread(String to) {
        this.to = to;
    }

    @Override
    public void run() {
        System.out.println("hello " + to);
    }
}

public static void main(String[] args) {
    new MyThread("world!").start();
}

Answer 4

Diese Antwort kommt sehr spät, aber vielleicht findet sie jemand nützlich. Es geht darum, wie man einen oder mehrere Parameter an eine Runnable ohne die benannte Klasse zu deklarieren (praktisch für Inliner):

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

Natürlich können Sie die Ausführung von start auf einen günstigeren oder angemesseneren Zeitpunkt verschieben. Und es liegt an Ihnen, was die Unterschrift des init Methode (sie kann also mehr und/oder andere Argumente annehmen) und natürlich auch ihren Namen, aber im Grunde haben Sie eine Vorstellung davon.

Es gibt noch eine weitere Möglichkeit, einen Parameter an eine anonyme Klasse zu übergeben, und zwar mit Hilfe der Initialisierungsblöcke. Betrachten Sie dies:

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

    new Thread(new Runnable() {
        private String myParam;
        private int myOtherParam;
        // instance initializer
        {
            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();

Alles geschieht also innerhalb des Initialisierungsblocks.

Answer 5

Wenn Sie einen Thread erstellen, benötigen Sie eine Instanz von Runnable . Der einfachste Weg, einen Parameter zu übergeben, wäre, ihn als Argument an den Konstruktor zu übergeben:

public class MyRunnable implements Runnable {

    private volatile String myParam;

    public MyRunnable(String myParam){
        this.myParam = myParam;
        ...
    }

    public void run(){
        // do something with myParam here
        ...
    }

}

MyRunnable myRunnable = new myRunnable("Hello World");
new Thread(myRunnable).start();

Wenn Sie dann den Parameter ändern wollen, während der Thread läuft, können Sie einfach eine Setter-Methode zu Ihrer runnable-Klasse hinzufügen:

public void setMyParam(String value){
    this.myParam = value;
}

Sobald Sie dies haben, können Sie den Wert des Parameters ändern, indem Sie wie folgt aufrufen:

myRunnable.setMyParam("Goodbye World");

Wenn Sie eine Aktion auslösen wollen, wenn der Parameter geändert wird, müssen Sie natürlich Sperren verwenden, was die Sache wesentlich komplexer macht.