距离我最初发布这篇文章已经将近9年了，老实说，Java自那以后已经有了一些改进。我会保留我的原始答案，但是现在没有必要再按照它的方式去做了。9年前，在代码审查期间，我可能会质疑他们为什么这样做，也许会批准，也许不会。随着现代lambda的出现，推荐一种过时的方法（公正地说，一开始就很可疑...）的高票答案是不负责任的。在现代Java中，那个代码审查将被立即拒绝，并建议使用以下方法：
void foo(final String str) {
Thread t = new Thread(() -> someFunc(str));
t.start();
}
与之前一样，如何有意义地处理该线程的细节留给读者自己去练习。但是坦白说，如果你害怕使用lambda表达式，那么你应该更加害怕多线程系统。
以下是原始答案：
您可以在方法中声明一个类。
void Foo(String str) {
class OneShotTask implements Runnable {
String str;
OneShotTask(String s) { str = s; }
public void run() {
someFunc(str);
}
}
Thread t = new Thread(new OneShotTask(str));
t.start();
}
Runnable了。有什么改变可以在Scheduler中使用它吗？例如：Scheduling scheduling = new Scheduling(1); scheduling.startScheduler(new MyRunnable(), TimeUnit.DAYS, 1); - BairDev你可以将它放在一个函数中。
String paramStr = "a parameter";
Runnable myRunnable = createRunnable(paramStr);
private Runnable createRunnable(final String paramStr){
Runnable aRunnable = new Runnable(){
public void run(){
someFunc(paramStr);
}
};
return aRunnable;
}
当我使用它时，我的参数是一个整数ID，我用它来创建一个ID--> myRunnables的哈希映射表。这样，我可以使用哈希映射表在处理程序中发布/删除不同的myRunnable对象。
Runnable 对象存在于任何地方，paramStr 可能就不会被垃圾回收。如果对象存在但无法再次运行，JIT（甚至 javac）可能会决定将其从作用域中删除，但我们不应该依赖这样的优化，因为它们可能会在未来发生变化。 - corsiKatheView.post(new Runnable() {
String str;
@Override
public void run() {
par.Log(str);
}
public Runnable init(String pstr) {
this.str=pstr;
return(this);
}
}.init(str));
Consumer<T> ：
https://docs.oracle.com/javase/8/docs/api/java/util/function/Consumer.html
它是功能接口之一，这意味着您可以将其作为lambda表达式调用：void doSomething(Consumer<String> something) {
something.accept("hello!");
}
...
doSomething( (something) -> System.out.println(something) )
...
void doSomething(String param) { CompletableFuture.runAsync(() -> howToDo(param));} private void howToDo(String param) { System.out.println(param);} - Lampard我使用下面的类来实现Runnable接口。 使用这个类，你可以很容易地创建带参数的新线程。
public abstract class RunnableArg implements Runnable {
Object[] m_args;
public RunnableArg() {
}
public void run(Object... args) {
setArgs(args);
run();
}
public void setArgs(Object... args) {
m_args = args;
}
public int getArgCount() {
return m_args == null ? 0 : m_args.length;
}
public Object[] getArgs() {
return m_args;
}
}
public RunnableArg(Object... args) {
setArgs(args);
}然后描述本地类：class ActionArg extends RunnableArg {
public ActionArg(Object... arg) {
super(arg);
}
@Override
public void run() {
/* getArgs() and process them */
}
}并使用它：Thread t = new Thread(new ActionArg( %param_object(s)% ));
t.start(); - GSD.Aaz你有两个选择：
定义一个命名类。将你的参数传递给该命名类的构造函数。
让你的匿名类封闭你的“参数”。确保将其标记为final。
我首先想知道你在这里试图达成什么目标，需要传递参数给new Runnable()或run()方法。 通常的做法应该是创建一个Runnable对象，在启动之前通过设置成员变量来向其线程传递数据（str）。然后run()方法使用这些成员变量的值来执行someFunc()。
/**
* @author AbdelWadoud Rasmi
* <p>
* The goal of this class is to pass some parameters to a runnable instance, a good example is
* after caching a file you need to pass the new path to user to do some work on it.
*/
public abstract class ParameterizedRunnable implements Runnable {
private Object[] params;
/**
* @param params: parameters you want to pass the the runnable.
*/
public ParameterizedRunnable(Object... params) {
this.params = params;
}
/**
* Code you want to run
*
* @param params:parameters you want to pass the the runnable.
*/
protected abstract void run(Object... params);
@Override
public final void run() {
run(params);
}
/**
* setting params
*/
public void setParams(Object... params) {
this.params = params;
}
/**
* getting params
*/
public Object[] getParams() {
return params;
}
}
目前为止最好的方法：
Consumer<String> oneShot = str -> {
somefunc(str);
};
oneShot.accept("myString");
public abstract class CCallback implements Runnable {
@Override
public void run() {}
public abstract void run(Object any);
}
现在你可以像这样使用这个类作为回调函数：
public void whatever(CCallback callback) {
String any = "any type of param";
if (callback != null)
callback.run(any);
}
无论什么"方法现在可以在我们的可运行程序运行之前完成其任务：
"whatever(new CCallback() {
@Override
public void run(Object any) {
// Here you can reach "any"
}
});
Consumer<T>。 - Alex78191Consumer<T>。 - Epaga