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.)。

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

猜你喜欢

转载自blog.csdn.net/dhq_blog/article/details/81481094