blocks|key|700076|text|如果直接调用run()，它将在调用线程上执行，就像任何其他方法调用一样。为了并行执行runnable的run方法，需要使用Thread.start()来实际创建一个新线程。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|700077|entityMap^0|6|5|1F|3|1P|E|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

If you just invoke <code>run()</code> directly, it's executed on the calling thread, just like any other method call. <code>Thread.start()</code> is required to actually create a new thread so that the runnable's <code>run</code> method is executed in parallel.

blocks|key|700308|text|不同之处在于，Thread.start()启动一个调用run()方法的线程，而Runnable.run()只调用当前线程上的run()方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|700309|entityMap^0|7|E|R|5|13|E|1Q|5|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

The difference is that <code>Thread.start()</code> starts a thread that calls the <code>run()</code> method, while <code>Runnable.run()</code> just calls the <code>run()</code> method on the current thread.

blocks|key|484400|text|实际上，Thread.start()创建了一个新线程并拥有自己的执行方案。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|484401|Thread.start()异步调用run()方法，这会将新线程的状态更改为Runnable。|484402|但是Thread.run()不会创建任何新线程。相反，它在当前运行的线程中同步执行run方法。|484403|如果你使用的是Thread.run()，那么你根本就没有使用多线程的特性。|484404|entityMap^0|4|E|0|0|E|I|5|0|2|C|0|7|C|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|M|$]]

Actually <code>Thread.start()</code> creates a new thread and have its own execution scenario.

<code>Thread.start()</code> calls the <code>run()</code> method asynchronously,which changes the state of new Thread to Runnable.

But <code>Thread.run()</code> does not create any new thread. Instead it execute the run method in the current running thread synchronously.

If you are using <code>Thread.run()</code> then you are not using the features of multi threading at all.

blocks|key|484577|text|invoke+run()在调用线程上执行，就像任何其他方法调用一样。而Thread.start()创建了一个新线程。调用run()是一个编程错误。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|484578|entityMap^0|7|5|Z|E|1O|5|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

invoke <code>run()</code> is executing on the calling thread, like any other method call. whereas <code>Thread.start()</code> creates a new thread.
invoking <code>run()</code> is a programmatic bug.

blocks|key|700280|text|如果您在main方法中执行run()，则main方法的线程将调用run方法，而不是您需要运行的线程。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|700281|start()方法创建新线程，并且必须对其执行run()方法|700282|entityMap^0|D|5|W|3|0|0|7|N|5|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

If you do <code>run()</code> in main method, the thread of main method will invoke the <code>run</code> method instead of the thread you require to run.

The <code>start()</code> method creates new thread and for which the <code>run()</code> method has to be done

blocks|key|700195|text|Thread.start()代码向调度器注册线程，调度器调用run()方法。此外，Thread是类，而Runnable是接口。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|700196|entityMap^0|0|E|U|5|15|6|1F|8|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

<code>Thread.start()</code> code registers the Thread with scheduler and the scheduler calls the <code>run()</code> method. Also, <code>Thread</code> is class while <code>Runnable</code> is an interface.

blocks|key|700402|text|成员们提出的观点都是正确的，所以我只想补充一些。问题是JAVA不支持多继承。但是，如果您想从另一个类A派生一个类B，但只能从一个类派生，该怎么办呢？现在的问题是如何从两个类“派生”：A和Thread。因此，您可以使用Runnable接口。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|700403|public+class+ThreadTest{
+++public+void+method(){
++++++Thread+myThread+=+new+Thread(new+B());
++++++myThread.start;
+++}
}

public+class+B+extends+A+implements+Runnable{...|code-block|syntax|javascript|700404|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 points, that the members made are all right so I just want to add something. The thing is that JAVA supports no Multi-inheritance. But What is if you want to derive a class B from another class A, but you can only derive from one Class. The problem now is how to "derive" from both classes: A and Thread. Therefore you can use the Runnable Interface.

<pre><code>public class ThreadTest{
 public void method(){
 Thread myThread = new Thread(new B());
 myThread.start;
 }
}

public class B extends A implements Runnable{...
</code></pre>

blocks|key|484754|text|如果直接调用run()方法，则不会使用多线程功能，因为run()方法是作为调用者线程的一部分执行的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|484755|如果在线程上调用start()方法，Java+Virtual+Machine将调用run()方法，两个线程将并发运行-当前线程(在您的示例中为main())和其他线程(在您的示例中为Runnable+r1+)。|484756|看看Thread+class中start()方法的源代码|484757|+/**
+++++*+Causes+this+thread+to+begin+execution;+the+Java+Virtual+Machine
+++++*+calls+the+<code>run</code>+method+of+this+thread.
+++++*+
+++++*+The+result+is+that+two+threads+are+running+concurrently:+the
+++++*+current+thread+(which+returns+from+the+call+to+the
+++++*+<code>start</code>+method)+and+the+other+thread+(which+executes+its
+++++*+<code>run</code>+method).
+++++*+
+++++*+It+is+never+legal+to+start+a+thread+more+than+once.
+++++*+In+particular,+a+thread+may+not+be+restarted+once+it+has+completed
+++++*+execution.
+++++*
+++++*+@exception++IllegalThreadStateException++if+the+thread+was+already
+++++*+++++++++++++++started.
+++++*+@see++++++++#run()
+++++*+@see++++++++#stop()
+++++*/
++++public+synchronized+void+start()+{
++++++++/**
+++++++++*+This+method+is+not+invoked+for+the+main+method+thread+or+"system"
+++++++++*+group+threads+created/set+up+by+the+VM.+Any+new+functionality+added
+++++++++*+to+this+method+in+the+future+may+have+to+also+be+added+to+the+VM.
+++++++++*
+++++++++*+A+zero+status+value+corresponds+to+state+"NEW".
+++++++++*/
++++++++if+(threadStatus+!=+0)
++++++++++++throw+new+IllegalThreadStateException();
++++++++group.add(this);
++++++++start0();
++++++++if+(stopBeforeStart)+{
++++++++++++stop0(throwableFromStop);
++++++++}
++++}

++++private+native+void+start0();|code-block|syntax|javascript|484758|在上面的代码中，您看不到对run()方法的调用。|484759|private+native+void+start0()负责调用run()方法。JVM执行这个本机方法。|484760|entityMap|0|LINK|mutability|MUTABLE|url|http://grepcode.com/file_/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/lang/Thread.java/?v=source^0|6|5|R|5|0|8|7|1Z|6|2S|2|0|F|7|2|C|0|0|0|D|5|0|0|S|W|5|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@$9|1F|A|1G|1|1H]]|E|$]]|$1|J|3|K|5|L|7|1I|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1M|8|@$9|1N|A|1O|B|C]|$9|1P|A|1Q|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

If you directly call <code>run()</code> method, you are not using multi-threading feature since <code>run()</code> method is executed as part of caller thread. 

If you call <code>start()</code> method on Thread, the Java Virtual Machine will call run() method and two threads will run concurrently - Current Thread (<code>main()</code> in your example) and Other Thread (Runnable <code>r1</code> in your example).

Have a look at source code of <code>start()</code> method in <a href="http://grepcode.com/file_/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/lang/Thread.java/?v=source" rel="nofollow">Thread class</a>

<pre><code> /**
 * Causes this thread to begin execution; the Java Virtual Machine
 * calls the &lt;code&gt;run&lt;/code&gt; method of this thread.
 * &lt;p&gt;
 * The result is that two threads are running concurrently: the
 * current thread (which returns from the call to the
 * &lt;code&gt;start&lt;/code&gt; method) and the other thread (which executes its
 * &lt;code&gt;run&lt;/code&gt; method).
 * &lt;p&gt;
 * It is never legal to start a thread more than once.
 * In particular, a thread may not be restarted once it has completed
 * execution.
 *
 * @exception IllegalThreadStateException if the thread was already
 * started.
 * @see #run()
 * @see #stop()
 */
 public synchronized void start() {
 /**
 * This method is not invoked for the main method thread or "system"
 * group threads created/set up by the VM. Any new functionality added
 * to this method in the future may have to also be added to the VM.
 *
 * A zero status value corresponds to state "NEW".
 */
 if (threadStatus != 0)
 throw new IllegalThreadStateException();
 group.add(this);
 start0();
 if (stopBeforeStart) {
 stop0(throwableFromStop);
 }
 }

 private native void start0();
</code></pre>

In above code, you can't see invocation to <code>run()</code> method. 

<code>private native void start0()</code> is responsible for calling <code>run()</code> method. JVM executes this native method.

blocks|key|700143|text|在第一种情况下，您只是调用r1和r2对象的run()方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|700144|在第二种情况下，你实际上是在创建两个新的线程！|700145|start()会在某个时刻调用run()！|700146|entityMap^0|D|2|G|2|L|5|0|0|0|7|F|5|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|K|$]]

In the first case you are just invoking the <code>run()</code> method of the <code>r1</code> and <code>r2</code> objects.

In the second case you're actually creating 2 new Threads!

<code>start()</code> will call <code>run()</code> at some point!

blocks|key|700458|text|Thread类中单独的start()和run()方法提供了两种创建线程化程序的方法。start()方法启动新线程的执行并调用run()方法。start()方法立即返回，新线程通常会继续运行，直到run()方法返回。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|700459|thread类的run()方法什么也不做，因此子类应该用要在第二个线程中执行的代码覆盖该方法。如果使用Runnable参数实例化Thread，则线程的run()方法将在新线程中执行Runnable对象的run()方法。|700460|根据线程程序的性质，直接调用thread+run()方法可以产生与通过start()方法调用相同的输出，但在后一种情况下，代码实际上是在新线程中执行的。|700461|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The separate start() and run() methods in the Thread class provide two ways to create threaded programs. The start() method starts the execution of the new thread and calls the run() method. The start() method returns immediately and the new thread normally continues until the run() method returns.

The Thread class' run() method does nothing, so sub-classes should override the method with code to execute in the second thread. If a Thread is instantiated with a Runnable argument, the thread's run() method executes the run() method of the Runnable object in the new thread instead.

Depending on the nature of your threaded program, calling the Thread run() method directly can give the same output as calling via the start() method, but in the latter case the code is actually executed in a new thread.

blocks|key|484794|text|Start()方法调用线程扩展类的run重写方法和Runnable实现接口。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|484795|但是通过调用run()，它会搜索run方法，但如果类实现了Runnable接口，那么它就会调用Runnable的run()覆盖方法。|484796|示例：|484797|`|484798|public+class+Main1
{
A+a=new+A();
B+b=new+B();
a.run();//This+call+run()+of+Thread+because+run()+of+Thread+only+call+when+class+
++++++++//implements+with+Runnable+not+when+class+extends+Thread.
b.run();//This+not+run+anything+because+no+run+method+found+in+class+B+but+it+
++++++++//didn't+show+any+error.

a.start();//this+call+run()+of+Thread
b.start();//this+call+run()+of+Thread
}

class+A+implements+Runnable{
@Override
++++public+void+run()+{
++++++++++++System.out.println("A+");
++++}
}

class+B+extends+Thread+{

++++@Override
++++public+void+run()+{
++++++++++++System.out.println("B+");
++++}
}|code-block|syntax|javascript|484799|484800|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|S|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|T|8|@]|9|@]|A|$K|L]]|$1|M|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|O|$]]

Start() method call run override method of Thread extended class and Runnable implements interface.

But by calling run() it search for run method but if class implementing Runnable interface then it call run() override method of Runnable.

ex.: 

`

<pre><code>public class Main1
{
A a=new A();
B b=new B();
a.run();//This call run() of Thread because run() of Thread only call when class 
 //implements with Runnable not when class extends Thread.
b.run();//This not run anything because no run method found in class B but it 
 //didn't show any error.

a.start();//this call run() of Thread
b.start();//this call run() of Thread
}

class A implements Runnable{
@Override
 public void run() {
 System.out.println("A ");
 }
}

class B extends Thread {

 @Override
 public void run() {
 System.out.println("B ");
 }
}
</code></pre>

`

Say we have these two Runnables:

<pre><code>class R1 implements Runnable {
 public void run() { … }
 …
}

class R2 implements Runnable {
 public void run() { … }
 …
}
</code></pre>

Then what's the difference between this:

<pre><code>public static void main() {
 R1 r1 = new R1();
 R2 r2 = new R2();

 r1.run();
 r2.run();
}
</code></pre>

And this:

<pre><code>public static void main() {
 R1 r1 = new R1();
 R2 r2 = new R2();
 Thread t1 = new Thread(r1);
 Thread t2 = new Thread(r2);

 t1.start();
 t2.start();
}
</code></pre>

What's the difference between Thread start() and Runnable run()

Java

假设我们有这两个Runnables：class R1 implements Runnable {    public void run() { … }    …}class R2 implements Runnable {    public void run() { … }    …}那么这两者之间有什么区别：public static void main() {    R1 r1 = new 

问Thread start()和Runnable run()有什么区别？
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Thread start()和Runnable run()有什么区别？EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Thread start()和Runnable run()有什么区别？
EN