Java多线程之 Thread VS Runnable 的区别

青旅半醒 2022-05-17 05:38 317阅读 0赞

摘自：[https://blog.csdn.net/uniquewonderq/article/details/48137767][https_blog.csdn.net_uniquewonderq_article_details_48137767]

![20150831181601989][]![20150831181609637][]

为此，**我们举个例子，假设有火车站**有**三个窗口，在卖火车票，总共只有5张票。每一个线程相当于一个窗口，分别售票**

1.  `<strong>package com.thread;`
2.   
3.  `class myThread extends Thread{`
4.   
5.  `private int ticketsCount=5;//一种有5张票`
6.  `private String name;//窗口，也即是线程的名字`
7.   
8.  `public myThread(String name){`
9.  `this.name=name;`
10. `}`
11.  
12. `@Override`
13. `public void run() {`
14. `while(ticketsCount>0) {`
15. `//ticketsCount--;//如果还有票，就卖掉一张`
16. `System.out.println(name+"有"+ticketsCount+"张票，卖了1一张票，剩余票数为："+ --ticketsCount);`
17. `//System.out.println(name+"卖了1一张票，剩余票数为："+ticketsCount);`
18. `}`
19. `}`
20.  
21.  
22.  
23. `}`
24. `public class TicketsTread {`
25.  
26. `public static void main(String args[]) {`
27. `//创建三个线程，模拟三个窗口卖票`
28. `myThread t1=new myThread("窗口1");`
29. `myThread t2=new myThread("窗口2");`
30. `myThread t3=new myThread("窗口3");`
31.  
32. `//启动这三个线程，也即是窗口开始卖票`
33. `t1.start();`
34. `t2.start();`
35. `t3.start();`
36. `}`
37. `}`
38.  
39. `</strong>`

输出为：![20150831181953515][]

这样的结果说明了，每个窗口（线程）都卖了5张票，这是因为创建了3个Thread对象，每个对象有自己的成员实例变量。

因为每个线程，mt1,mt2,mt3分别是一个继承了Thread类的一个对象，所以对象拥有其所属类的私有或共有的成员变量或者成员方法，也就是说他们的变量，也即是票数ticketCount都是每个对象“自己”私有的，“各自为营”，资源并不是共享的。 那么，你就会看到，每个窗口都有5张票的情况咯。。

再使用runnable 来实现这个示例。

1.  `package com.thread;`
2.   
3.  `class myThread_Runnable implements Runnable{`
4.  `private int ticketsCount=5;//一种有5张票`
5.   
6.  `public void run() {//如果给run方法加锁，那么会出现一个窗口会卖光所有票的现象`
7.  `while(ticketsCount>0) {`
8.  `ticketsCount--;//如果还有票，就卖掉一张`
9.  `System.out.println(Thread.currentThread().getName()+"卖了1一张票，剩余票数为："+ticketsCount);`
10. `}`
11. `}`
12.  
13. `}`
14.  
15. `public class TicketsRunnable {`
16.  
17. `public static void main(String args[]){`
18. `myThread_Runnable mt=new myThread_Runnable();`
19. `//创建三个线程，来模拟三个售票窗口`
20. `Thread t1=new Thread(mt,"窗口1");`
21. `Thread t2=new Thread(mt,"窗口2");`
22. `Thread t3=new Thread(mt,"窗口3");`
23.  
24. `//启动这三个线程，也即是三个窗口，开始卖票`
25. `t1.start();`
26. `t2.start();`
27. `t3.start();`
28. `}`
29. `}`

![20150831182612716][]

上面这个是一个及其特殊的情况，线程（窗口）1一次性的使用了CPU并执行完了了run方法的所有代码，然后进程结束。

下面这个是一般性的结果：

![20150831182726157][]

例2.

![70][]

![70 1][]

总结：1.继承thread只，线程不共享，每个线程只是针对一个线程。

2.实现Runnable接口，可以线程共享，如果多个thread线程实体的参数是同一个Runnable接口实体，则实现线程共享，如果thread参数不是同一个Runnable接口实体，则每个线程就是单独的一个对象（此时不共享：例2.）。

上面这个输出就可以看出来，线程资源抢夺所导致的交叉执行。

[https_blog.csdn.net_uniquewonderq_article_details_48137767]: https://blog.csdn.net/uniquewonderq/article/details/48137767
[20150831181601989]: https://img-blog.csdn.net/20150831181601989
[20150831181609637]: /images/20220517/a9918c5f8676477c908a62ab5383f64b.png
[20150831181953515]: /images/20220517/e20bb3740a8f4b2d8557c5c498ab53d9.png
[20150831182612716]: /images/20220517/f2007fdc17e44235a3de196380e931df.png
[20150831182726157]: /images/20220517/c2eacce0ca564132bb0e608af9aba63e.png
[70]: /images/20220517/d5d5da1f3b164172b068cd04d8de6b4b.png
[70 1]: /images/20220517/cb04cc61bfe34423bc7fa1005470ec21.png