Java多线程之 Thread VS Runnable 的区别

摘自：https://blog.csdn.net/uniquewonderq/article/details/48137767

 

为此，我们举个例子，假设有火车站有三个窗口，在卖火车票，总共只有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>

 

 

输出为：

 

 

这样的结果说明了，每个窗口（线程）都卖了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. }

 

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

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

例2.

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

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

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