blocks|key|1108588|text|我在java.lang.Thread文档中看不到这样做的任何方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1108589|因此，我最好的回答是，您可能应该使用List<Runnable>而不是List<Thread>+(或除了它之外)。或者，您可能想要某种map结构，以便可以从线程访问Runnable。(例如，java.util.HashMap<java.lang.Thread,+java.lang.Runnable>)|1108590|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Thread.html|1|http://java.sun.com/j2se/1.5.0/docs/api/java/util/Map.html^0|2|G|2|G|0|0|I|E|Z|C|2N|1J|1V|3|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@$9|14|A|15|1|16]]|E|$]]|$1|H|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]]]

I don't see any way to do it in the <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Thread.html" rel="noreferrer"><code>java.lang.Thread</code></a> docs.

My best answer, then, is that you probably should be using <code>List&lt;Runnable&gt;</code> instead of (or in addition to) <code>List&lt;Thread&gt;</code>. Or perhaps you want some sort of <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/Map.html" rel="noreferrer">map</a> structure so that you can access the Runnable from the Thread. (For example, <code>java.util.HashMap&lt;java.lang.Thread, java.lang.Runnable&gt;</code>)

blocks|key|1108647|text|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);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1108648|顺便说一句，在实际案例中，你需要使用Callable和FutureTask|unstyled|offset|length|style|CODE|1108649|entityMap^0|0|I|8|R|A|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]|$G|Q|H|R|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|S|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>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);
</code></pre>

BTW, in real case you need to use <code>Callable</code> and <code>FutureTask</code>

blocks|key|1108701|text|这就是你可以直接实现它的方式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1108702|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);
}|code-block|syntax|javascript|1108703|然而，现代的(不易出错的)方法是在java.util.concurrent中使用更高级别的并发类。|offset|length|style|CODE|1108704|entityMap^0|0|0|H|K|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This is how you could implement this directly.

<pre><code>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);
}
</code></pre>

However, the modern (less error prone) way to do this kind of thing is to use the higher-level concurrency classes in <code>java.util.concurrent</code>.

blocks|key|1323839|text|如果您想返回异步计算的值，请查看Callable和FutureTask：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1323840|FutureTask<String>+task+=+new+FutureTask(new+Callable<String>()+{
+++public+String+call()+{
++++++return+"world";
+++}
});
new+Thread(task).start();
String+result+=+task.get();|code-block|syntax|javascript|1323841|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you want to return the value of an asynchronous calculation, look at Callable and FutureTask:

<pre><code>FutureTask&lt;String&gt; task = new FutureTask(new Callable&lt;String&gt;() {
 public String call() {
 return "world";
 }
});
new Thread(task).start();
String result = task.get();
</code></pre>

blocks|key|1108820|text|并发库很好地支持了这一点。注意:如果您的任务抛出异常，Future将保留此异常，并在调用get()时抛出包装异常。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1108821|ExecutorService+executor+=+Executors.newSingleThreadedExecutor();

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

String+result+=+future.get();+|code-block|syntax|javascript|1108822|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The concurrency library supports this well. Note: If your task throws an Exception, the Future will hold this and throw a wrapping exception when you call get()

<pre><code>ExecutorService executor = Executors.newSingleThreadedExecutor();

Future&lt;String&gt; future = executor.submit(new Callable&lt;String&gt;() { 
 public String call() { 
 return "world"; 
 } 
}); 

String result = future.get(); 
</code></pre>

blocks|key|1323943|text|我认为一般来说，你可以/应该避免这样做，但如果你真的需要这样做，就不应该像MatrixFrog的建议那样工作(未经测试)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1323944|class+RunnableReferencingThread+extends+Thread+{
++++public+final+Runnable+runnable;
++++public+RunnableReferencingThread(Runnable+r)+{
++++++++super(r);
++++++++this.runnable+=+r;
++++}
}|code-block|syntax|javascript|1323945|1323946|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

I think in general you can/should avoid doing this, but if you really need to do it shouldn't something like MatrixFrog's suggestion work (untested):

<pre><code>class RunnableReferencingThread extends Thread {
 public final Runnable runnable;
 public RunnableReferencingThread(Runnable r) {
 super(r);
 this.runnable = r;
 }
}
</code></pre>

?

blocks|key|1324016|text|你可以子类化Thread，然后添加你需要的方法。由于Thread的一些恼人的实现细节，您必须保持自己的目标副本可运行，并覆盖用于创建Thread的所有Thread构造函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1324017|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You could subclass Thread, and add the method you need. You'll have to keep your own copy of the target Runnable and override all the Thread constructors you use to create the Thread, because of some annoying implementation details of Thread.

blocks|key|1324030|text|我也有同样的问题。以下是我的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1324031|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;
}|code-block|syntax|javascript|1324032|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I had the same problem. Here is my solution:

<pre><code>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;
}
</code></pre>

blocks|key|1108994|text|如果你的线程有状态信息，忘记Runnable，简单地扩展Thread，覆盖run方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1108995|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If your thread has state information, forget Runnable and simply extend Thread, overriding the run method.

blocks|key|1109055|text|举一个具体的例子来说明Paul+Crowley的解决方案，我认为这就是他的建议：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1109056|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;
++++}

}|code-block|syntax|javascript|1109057|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

To give a concrete example of Paul Crowley's solution, I think this is what he suggests:

<pre><code>public class BackgroundJob&lt;JOB extends Runnable&gt; extends Thread {

 private final JOB mJob;

 public BackgroundJob(JOB job) {
 super(job);
 mJob = job;
 }

 public JOB getJob() {
 return mJob;
 }

}
</code></pre>

blocks|key|1324170|text|我认为，如果可以的话，那就是扭转局面。那么，在这种情况下，一个很好的解决方案是将线程存储在runnable类中。您的runnable有一个start()函数，该函数启动并启动本地线程并调用thread.start。像这样，你可以拥有一个线程对象的列表。你也可以有一个访问器来获取线程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1324171|public+class+Threaded+extends+other+implements+Runnable+{
++++Thread+localThread;

++++@Override
++++public+void+run()+{
++++++++//...
++++}

++++public+void+start()+{
++++++++localThread+=+new+Thread(this);
++++++++localThread.start();
++++}

}|code-block|syntax|javascript|1324172|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I think, if you can, it is to revert the situation. Then in this case a good solution is to store the thread in your runnable class. And your runnable has a start() function that launch and start itself the local thread and call thread.start. Like this you can have a list of your threaded objects. Also you can have an accessor to get the thread.

<pre><code>public class Threaded extends other implements Runnable {
 Thread localThread;

 @Override
 public void run() {
 //...
 }

 public void start() {
 localThread = new Thread(this);
 localThread.start();
 }

}
</code></pre>

Possible duplicate: <a href="https://stackoverflow.com/questions/2300433/need-help-returning-object-in-thread-run-method">need-help-returning-object-in-thread-run-method</a> 

Hello. I have a class implementing runnable and I have a List, storing Threads instantiated with different objects of that class. How can I access properties of underlying objects given the thread object running them? Here is an example:

<pre><code>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?
 }
}
</code></pre>

How to access a Runnable object by Thread?

可能的重复项：你好。我有一个实现runnable的类，我有一个List，存储用该类的不同对象实例化的Thread。给定运行底层对象的线程对象，我如何访问它们的属性？下面是一个示例：public class SO {    public static class TestRunnable implements Runna...

问如何通过线程访问Runnable对象？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何通过线程访问Runnable对象？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何通过线程访问Runnable对象？
EN