通过Runnable或Thread类的构造函数

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

你需要在构造函数中将参数传递给Runnable对象:

public class MyRunnable implements Runnable {

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

   public void run() {
   }
}

并这样调用它:

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

还有一个选择;这种方法允许您像使用异步函数调用一样使用Runnable项。如果你的任务不需要返回一个结果，例如，它只是执行一些操作，你不需要担心如何传递回一个“结果”。

此模式允许您重用需要某种内部状态的项。当不在构造函数中传递参数时，需要注意调节程序对参数的访问。如果您的用例涉及不同的调用者，您可能需要更多的检查。

public class MyRunnable implements Runnable 
{
  private final Boolean PARAMETER_LOCK  = false;
  private X parameter;

  public MyRunnable(X parameter) {
     this.parameter = parameter;
  }

  public void setParameter( final X newParameter ){

      boolean done = false;
      synchronize( PARAMETER_LOCK )
      {
          if( null == parameter )
          {
              parameter = newParameter;
              done = true;
          }
      }
      if( ! done )
      {
          throw new RuntimeException("MyRunnable - Parameter not cleared." );
      }
  }


  public void clearParameter(){

      synchronize( PARAMETER_LOCK )
      {
          parameter = null;
      }
  }


  public void run() {

      X localParameter;

      synchronize( PARAMETER_LOCK )
      {
          localParameter = parameter;
      }

      if( null != localParameter )
      {
         clearParameter();   //-- could clear now, or later, or not at all ...
         doSomeStuff( localParameter );
      }

  }

}

线程=新的线程(新的MyRunnable(参数)); t.start ();

如果您需要处理的结果，您还需要在子任务完成时协调MyRunnable的完成。你可以传递一个回调或者只是等待线程't'，等等。

通过Runnable或Thread类的构造函数

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

首先，我想指出其他答案都是正确的。 但是，在构造函数中使用形参可能对所有人来说都不是最好的主意。

在很多情况下，你会想要使用“匿名内部类”，并重写run()方法，因为为每个用途定义特定的类是很痛苦的。 (新MyRunnable(){…})

在创建Runnable时，参数可能无法在构造函数中传递。例如，如果你将这个对象传递给一个方法，这个方法将在单独的线程中执行一些工作，然后调用你的runnable，将该工作的结果应用到它。

在这种情况下，使用如下方法: public MyRunnable withParameter(对象参数)，可能是更有用的选择。

我并不是说这是解决问题的最好办法，但它可以解决问题。

这个答案来得很晚，但也许有人会觉得它有用。它是关于如何在不声明命名类的情况下将参数传递给Runnable(对于内联程序来说很方便):

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

当然，您可以将start的执行推迟到某个更方便或合适的时刻。这取决于你init方法的签名(所以它可能需要更多和/或不同的参数)，当然甚至它的名字，但基本上你得到了一个想法。

事实上，还有另一种将参数传递给匿名类的方法，即使用初始化块。考虑一下:

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

所有都发生在初始化程序块内部。