blocks|key|3206833|text|调用thread.start()，它将依次调用thread.run()。我想不出什么情况下您会想绕过thread.start()而直接转到thread.run()|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3206834|entityMap^0|2|E|N|C|1E|E|1X|C|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|$]]

Call <code>thread.start()</code>, it will in turn call <code>thread.run()</code>. Can't think of a case when you would want to bypass <code>thread.start()</code> and go directly to <code>thread.run()</code>

blocks|key|3206930|text|绝不可能。直接调用run()只是同步执行代码(在同一线程中)，就像普通的方法调用一样。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3206931|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|$]]

Never. Calling run() directly just executes the code synchronously (in the same thread), just like a normal method call.

blocks|key|861997|text|当你想让它同步运行时。调用run方法实际上不会提供多线程。start方法创建一个调用run方法的新线程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|861998|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|$]]

When you want it to run synchronously. Calling the run method won't actually give you multi-threading. The start method creates a new thread which calls the run method.

blocks|key|4053364|text|取自Code+Style+Java+threads+FAQ|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4053365|4053366|问:线程的start()和run()方法有什么区别？|blockquote|4053367|4053368|答:+Thread类中单独的start()和run()方法提供了两种创建线程化程序的方法。start()方法启动新线程的执行并调用run()方法。start()方法立即返回，新线程通常会继续运行，直到run()方法返回。|4053369|thread类的run()方法什么也不做，因此子类应该用要在第二个线程中执行的代码覆盖该方法。如果使用Runnable参数实例化Thread，则线程的run()方法将在新线程中执行Runnable对象的run()方法。|4053370|根据线程程序的性质，直接调用Thread+run()方法可以产生与通过start()方法调用相同的输出，但在后一种情况下，代码实际上是在新线程中执行的。|4053371|entityMap|0|LINK|mutability|MUTABLE|url|http://www.codestyle.org/java/faq-Threads.shtml#threadstartrun^0|2|R|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|-4|5|6|7|10|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|11|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|12|8|@]|9|@]|C|$]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

Taken form the <a href="http://www.codestyle.org/java/faq-Threads.shtml#threadstartrun" rel="noreferrer">Code Style Java threads FAQ</a>:
<blockquote>
Q: What's the difference between a
thread's start() and run() methods?
A: 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.
</blockquote>

blocks|key|4053409|text|如果您想像执行任何其他方法一样执行run()的内容。当然，不是为了启动线程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4053410|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 you want to execute the contents of run() like you would of any other method. Not to start a thread, of course.

blocks|key|4053479|text|您可能希望在严格关注功能而不是并发的特定单元测试中调用run()。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4053480|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 might want to call run() in a particular unit test that is concerned strictly with functionality and not with concurrency.

blocks|key|3207277|text|假设您知道start和run方法的用法，即同步和异步；run方法可以用来测试功能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3207278|另外，在某些情况下，同一个线程类可以在两个不同的地方使用，具有同步和异步功能要求，方法是使用两个不同的对象，一个对象的run方法和另一个对象的start方法被调用。|3207279|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Assuming that you know the start and run method usage i.e. synchronous vs. asynchronous; run method can be used just to test the functionality. 

Plus in some circumstances, the same thread class can be used in two different places with synch and asynch functionality requirements by having two different objects with one's run method and other's start method being invoked.

blocks|key|3207318|text|至少在JVM1.6.中，有一些检查和运行被本机调用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3207319|+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|3207320|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|$]]

At least in the JVM 1.6., there's a bit of checking and run is called natively:

<pre><code> 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>

blocks|key|5465196|text|这一点已经提到过了，但为了清楚起见:创建一个新的Thread对象只是为了调用它的run()方法，这是不必要的开销，应该是一个主要的危险信号。如果创建一个Runnable+impl，并且(a)直接调用它的run()方法(如果这是所需的行为)，或者(b)使用该Runnable构造一个新的Thread并启动Thread，这将是一个更好、更解耦的设计。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5465197|更好的是，要获得更多的解耦，请查看JDK5和更高版本中的Executor接口和框架。简而言之，这允许您将任务执行(可运行实例)与其执行方式(+Executor实现，它可能在当前线程、新线程、使用池中的现有线程等中执行Runnable+)解耦。|offset|length|style|CODE|5465198|entityMap^0|0|S|8|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

This has already been alluded to, but just to be clear: creating a new Thread object only to call it's run() method is needlessly expensive and should be a major red flag. It would be a much better, more decoupled design to create a Runnable impl and either (a) call it's run() method directly if that's the desired behavior, or (b) construct a new Thread with that Runnable and start the Thread.

Better yet, for even more decoupling, check out the <code>Executor</code> interface and framework in JDK 5 and newer. This allows you, in a nutshell, to decouple task execution (the Runnable instance) from how it is executed (the Executor implementation, which might execute the Runnable in the current Thread, in a new Thread, using an existing Thread from a pool, and whatnot).

blocks|key|862241|text|Thread类中单独的start()和run()方法提供了两种创建线程化程序的方法。start()方法启动新线程的执行并调用run()方法。start()方法会立即返回，并且新线程通常会继续运行，直到run()方法返回。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|862242|Thread类的run()方法什么也不做，因此子类应该用要在第二个线程中执行的代码覆盖该方法。如果线程是使用Runnable参数实例化的，则该线程的run()方法将改为在新线程中执行Runnable对象的run()方法。|862243|根据线程程序的性质，直接调用线程run()方法可以产生与通过start()方法调用相同的输出，但在后一种情况下，代码实际上是在新线程中执行的。|862244|reference+|862245|entityMap|0|LINK|mutability|MUTABLE|url|http://www.edugoing.com/qna/index.php?qa=95&qa_1=what-the-difference-between-thread-start-thread-run-method^0|B|7|J|5|16|7|1Q|5|1Y|7|2S|5|0|8|5|22|5|2U|5|0|G|5|U|7|0|0|A|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1I|8|@]|D|@$9|1J|A|1K|1|1L]]|E|$]]|$1|L|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|M|$N|$5|O|P|Q|E|$R|S]]]]

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

The Thread class’ <code>run()</code> 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 <code>run()</code> method executes the <code>run()</code> method of the Runnable object in the new thread instead.

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

<a href="http://www.edugoing.com/qna/index.php?qa=95&amp;qa_1=what-the-difference-between-thread-start-thread-run-method" rel="noreferrer">reference </a>

blocks|key|3207479|text|如果问题是-“为什么调用线程start方法而不是直接调用run方法”，那么我已经用下面的示例代码回答了。希望能澄清这一点。在下面的示例中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3207480|/*
By+calling+t1.start(),+
we+are+getting+the+main+calling+thread+returned+immediately+
after+the+t1.start()+called+and+is+ready+to+proceed+for+other+
operations.And+the+thread+t1+starts+executing+the+run+method+of+the+object+r.+
Hence+the+the+output+will+be:

++++++I+am+the+main+thread+,+i+created+thread+t1+and+had+it+execute+run+method,+which+is+currently+looping+from+0+to+1000000

++++++I+am+done+executing+run+method+of+testThread

*/


/*+If+we+call+t1.run()+instead+of+t1.start(),+(just+replace+t1.start()+with+t1.run()+in+the+code+for+testing)
+its+like+a+regular+method+call+and+the+main+thread+will+not+return+until+the+run+method+completes,+
+hence+the+output+will+be:

+++++++++I+am+done+executing+run+method+of+testThread

+++++++++I+am+the+main+thread+,+i+created+thread+t1+and+had+it+execute+run+method,+which+is+currently+looping+for+i+to+1000000

*/


class+testThread+implements+Runnable{

+public+void+run()
+{
+++++for(int+i=0;i<1000000;i%2B%2B){}+//a+simple+delay+block+to+clarify.

+++++System.out.println("I+am+done+executing+run+method+of+testThread");

+}++
}

public+class+mainClass{

+++public+static+void+main(String+[]+args)
++++{
++++++++++testThread+r+=+new+testThread();
++++++++++Thread+t1+=+new+Thread(r);
++++++++++t1.start();++/*+Question+is:+can+we+call+instead+t1.run()+*/++
++++++++++System.out.println("I+am+the+main+thread+,+i+created+thread+t1+and+had+it+execute+run+method,+which+is+currently+looping+for+i+to+1000000");

++++}
}|code-block|syntax|javascript|3207481|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 the Question was - "why the thread start method is called instead of run method directly" then i have answered with an example code below. Hope that clarifies.
In the Example below: 

<pre><code>/*
By calling t1.start(), 
we are getting the main calling thread returned immediately 
after the t1.start() called and is ready to proceed for other 
operations.And the thread t1 starts executing the run method of the object r. 
Hence the the output will be:

 I am the main thread , i created thread t1 and had it execute run method, which is currently looping from 0 to 1000000

 I am done executing run method of testThread

*/


/* If we call t1.run() instead of t1.start(), (just replace t1.start() with t1.run() in the code for testing)
 its like a regular method call and the main thread will not return until the run method completes, 
 hence the output will be:

 I am done executing run method of testThread

 I am the main thread , i created thread t1 and had it execute run method, which is currently looping for i to 1000000

*/


class testThread implements Runnable{

 public void run()
 {
 for(int i=0;i&lt;1000000;i++){} //a simple delay block to clarify.

 System.out.println("I am done executing run method of testThread");

 } 
}

public class mainClass{

 public static void main(String [] args)
 {
 testThread r = new testThread();
 Thread t1 = new Thread(r);
 t1.start(); /* Question is: can we call instead t1.run() */ 
 System.out.println("I am the main thread , i created thread t1 and had it execute run method, which is currently looping for i to 1000000");

 }
}
</code></pre>

blocks|key|3207541|text|执行thread.run()不会创建在其中执行代码的新Thread。它只执行从其中调用thread.run()代码的当前线程中的代码。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3207542|执行thread.start()会创建一个新的操作系统级线程，其中调用run()方法。|3207543|本质上：|3207544|3207545|单线程编程→直接调用run()方法多线程编程→调用start()方法|blockquote|3207546|3207547|3207548|此外，正如其他人所提到的，“测试”似乎是您可以直接从代码中调用run()的唯一明智的情况。|3207549|entityMap^0|2|C|R|6|17|C|0|2|E|Z|5|0|0|0|A|5|P|7|0|0|0|V|5|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|15|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|16|8|@]|D|@]|E|$]]|$1|K|3|L|5|M|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|R|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|S|$]]

Executing <code>thread.run()</code> doesn't create a new <code>Thread</code> in which your code gets executed. It just executes the code in the current Thread from which the <code>thread.run()</code> code is invoked.

Executing <code>thread.start()</code> creates a new OS level thread wherein the <code>run()</code> method gets called.

In essence:

<blockquote>
 Single Threaded programming → Directly calling the <code>run()</code> method
</blockquote>



<blockquote>
 Multi Threaded programming → Calling the <code>start()</code> method
</blockquote>

Moreover, as other's have mentioned, 'testing' seems to be the only advisable case wherein you may invoke <code>run()</code> directly from your code.

blocks|key|857091|text|只需注意上面的注释:有时您编写的多线程代码使用"start“方法来运行不同的线程。如果您使用"+run“(而不是”start“)进行调试，您会发现这会容易得多，因为它可以使代码同步运行，并使调试变得更容易。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|857092|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|$]]

Just a note to the above great comments: sometimes your write a multi-thread code which uses "start" method to run different threads. You will find it much easier if you use "run" (instead of "start) for debugging since it makes the code to run synchronously and debugging it much easier.

blocks|key|4054148|text|public+class+TestClass+implements+Runnable+{
++++public+static+void+main(String[]+args)+{
++++++++TestClass+tc+=+new+TestClass();

++++++++Thread+t1+=+new+Thread(tc);
++++++++System.out.println("Before+Starting+Thread+"+%2B+Thread.currentThread().hashCode());
++++++++t1.start();
++++++++System.out.println("After+Starting+Thread+"+%2B+Thread.currentThread().hashCode());
++++}

++++@Override
++++public+void+run()+{
++++++++System.out.println("TestClass+Run+method+is++Running+with+thread+"+%2B+Thread.currentThread().hashCode());++++++++
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4054149|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public class TestClass implements Runnable {
 public static void main(String[] args) {
 TestClass tc = new TestClass();

 Thread t1 = new Thread(tc);
 System.out.println("Before Starting Thread " + Thread.currentThread().hashCode());
 t1.start();
 System.out.println("After Starting Thread " + Thread.currentThread().hashCode());
 }

 @Override
 public void run() {
 System.out.println("TestClass Run method is Running with thread " + Thread.currentThread().hashCode()); 
 }
}
</code></pre>

When would you call Java's <code>thread.run()</code> instead of <code>thread.start()</code>?

When would you call java's thread.run() instead of thread.start()?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

什么时候调用Java的thread.run()而不是thread.start()

问什么时候你会调用java的thread.run()而不是thread.start()？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候你会调用java的thread.run()而不是thread.start()？EN