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

小灰灰 2022-08-25 14:45 242阅读 0赞

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代码 [ ![复制代码][icon_copy.gif]][_icon_copy.gif]  ![收藏代码][icon_star.png]![spinner.gif][]

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为两种不同情况的比较：  
  
![点击查看原始大小图片][63b75f60-2fa7-3c21-8d60-8ee4cd58a732.jpg]

例程4：

Java代码 [ ![复制代码][icon_copy.gif]][_icon_copy.gif]  ![收藏代码][icon_star.png]![spinner.gif][]

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.

[icon_copy.gif]: http://supportopensource.iteye.com/images/icon_copy.gif
[_icon_copy.gif]: http://supportopensource.iteye.com/blog/773257#
[icon_star.png]: http://supportopensource.iteye.com/images/icon_star.png
[spinner.gif]: /images/20220824/a8e2da489df54019835d946d34fed722.png
[63b75f60-2fa7-3c21-8d60-8ee4cd58a732.jpg]: /images/20220824/1042d89effe5410283cb8d8f8d4291d3.png