Java多线程之 Thread VS Runnable

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

[java] view plaincopy

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 来实现这个示例。

[java] view plaincopy

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方法的所有代码，然后进程结束。

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

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