Thread的run（）与start（）的区别

1、start()方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。

通过调用Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。然后JVM通过此Thread类调用方法run()来完成其运行操作的，这里方法run()称为线程执行体，它包含了要执行的这个线程的内容，run方法运行结束，此线程终止，而CPU再运行其它线程，

2、run()方法当作普通方法的方式调用，程序还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码。

如果直接用run方法，这只是调用一个方法而已，程序中依然只有主线程，只有这一个线程，其程序执行路径还是只有一条，这样就没有达到写线程的目的。

记住：线程就是为了更好地利用CPU，提高程序运行速率的！

 

 

 Thread的start和run

1） start：

用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里方法run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。

2） run：

run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。

 

 

为了更好地理解两者的区别，看以下的例子：
例程1：

Java代码  

1. public class TestThread {  
2.     public static void main(String arg[]){  
3.         NewThread t1 = new NewThread();  
4.         NewThread t2 = new NewThread();  
5.         Thread th1 = new Thread(t1);  
6.         Thread th2 = new Thread(t2);  
7.         System.out.println(Thread.currentThread().getName() );  
8.         th1.start();  
9.         th2.start();  
10.         //th1.run();  
11.         //th2.run();  
12.     }  
13. }  
14. class NewThread implements Runnable{  
15.     int i = 0;  
16.     public void run() {  
17.         for(int i = 0; i <20;i ++){  
18.             System.out.println(Thread.currentThread().getName() +"   "+ i);  
19.         }  
20.     }  
21. }  

public class TestThread {public static void main(String arg[]){NewThread t1 = new NewThread();NewThread t2 = new NewThread();Thread th1 = new Thread(t1);Thread th2 = new Thread(t2);System.out.println(Thread.currentThread().getName() );th1.start();th2.start();//th1.run();//th2.run();}}class NewThread implements Runnable{int i = 0;public void run() {for(int i = 0; i <20;i ++){System.out.println(Thread.currentThread().getName() +"   "+ i);}}}

程序的运行结果1（//th1.run();//th2.run();）：
main
Thread-0   0
Thread-0   1
Thread-1   0
Thread-0   2
Thread-1   1
Thread-1   2
Thread-0   3
Thread-1   3
Thread-0   4
Thread-1   4
Thread-0   5
Thread-0   6
Thread-1   5
Thread-0   7
Thread-1   6
Thread-0   8
Thread-1   7
Thread-0   9
Thread-1   8
Thread-0   10
Thread-0   11
Thread-0   12
Thread-1   9
Thread-0   13
Thread-0   14
Thread-1   10
Thread-0   15
Thread-0   16
Thread-1   11
Thread-0   17
Thread-1   12
Thread-0   18
Thread-1   13
Thread-0   19
Thread-1   14
Thread-1   15
Thread-1   16
Thread-1   17
Thread-1   18
Thread-1   19
程序的运行结果2：（//th1.start();//th2.start();）
main
main   0
main   1
main   2
main   3
main   4
main   5
main   6
main   7
main   8
main   9
main   10
main   11
main   12
main   13
main   14
main   15
main   16
main   17
main   18
main   19
main   0
main   1
main   2
main   3
main   4
main   5
main   6
main   7
main   8
main   9
main   10
main   11
main   12
main   13
main   14
main   15
main   16
main   17
main   18
main   19

运行结果分析：线程对象调用start()方法，就表示启动了线程，即又产生了一条执行线索。而调用run()方法，只是相当于普通的方法调用，并没有产生新的执行线索，run()方法仍然在调用它的线程中执行。

如下图1为两种不同情况的比较：

 

例程4：

Java代码  

1. public class TestThread {  
2.     public static void main(String arg[]){  
3.         NewThread t1 = new NewThread();  
4.         NewThread t2 = new NewThread();  
5.         Thread th1 = new Thread(t1);  
6.         Thread th2 = new Thread(t2);  
7.         for(int i = 0; i <20;i ++){  
8.             System.out.println(Thread.currentThread().getName() +"   "+ i);  
9.         }  
10.         th1.run();  
11.         th2.run();  
12.     }  
13. }  
14. class NewThread implements Runnable{  
15.     int i = 0;  
16.     public void run() {  
17.         for(int i = 0; i <20;i ++){  
18.             System.out.println(Thread.currentThread().getName() +"   "+ i);  
19.         }  
20.     }  
21. }  

public class TestThread {public static void main(String arg[]){NewThread t1 = new NewThread();NewThread t2 = new NewThread();Thread th1 = new Thread(t1);Thread th2 = new Thread(t2);for(int i = 0; i <20;i ++){System.out.println(Thread.currentThread().getName() +"   "+ i);}th1.run();th2.run();}}class NewThread implements Runnable{int i = 0;public void run() {for(int i = 0; i <20;i ++){System.out.println(Thread.currentThread().getName() +"   "+ i);}}}

程序运行结果如下：
main   0
main   1
main   2
main   3
main   4
main   5
main   6
main   7
main   8
main   9
main   10
main   11
main   12
main   13
main   14
main   15
main   16
main   17
main   18
main   19
main   0
main   1
main   2
main   3
main   4
main   5
main   6
main   7
main   8
main   9
main   10
main   11
main   12
main   13
main   14
main   15
main   16
main   17
main   18
main   19
main   0
main   1
main   2
main   3
main   4
main   5
main   6
main   7
main   8
main   9
main   10
main   11
main   12
main   13
main   14
main   15
main   16
main   17
main   18
main   19
说明：在这种情况下才会产生惟一结果。线程对象直接调用run()方法，在主线程中顺序执行。

 

 

同时摘取一段外文网站论坛上的解释：
Why do we need start() method in Thread class? In Java API description for Thread class is written : "Java Virtual Machine calls the run method of this thread..".

Couldn't we call method run() ourselves, without doing double call: first we call start() method which calls run() method? What is a meaning to do things such complicate?



 

There is some very small but important difference between using start() and run() methods. Look at two examples below:

Example one:

Code:

Thread one = new Thread();
Thread two = new Thread();
one.run();
two.run();

Example two:

Code:

Thread one = new Thread();
Thread two = new Thread();
one.start();
two.start();

The result of running examples will be different.

In Example one the threads will run sequentially: first, thread number one runs, when it exits the thread number two starts. 只能顺序执行，是同步的

In Example two both threads start and run simultaneously.同时启动进入就绪状态，是异步执行的

Conclusion: the start() method call run() method asynchronously异步 (does not wait for any result, just fire up an action), while we run run() method synchronously同步 - we wait when it quits and only then we can run the next line of our code.