Java 实现Runnable接口 资源共享

一.先看两段代码

通过继承Thread类

1. class MyThread extends Thread{  
2.       
3.     private int ticket = 10;  
4.     private String name;  
5.     public MyThread(String name){  
6.         this.name =name;  
7.     }  
8.       
9.     public void run(){  
10.         for(int i =0;i<500;i++){  
11.             if(this.ticket>0){  
12.                 System.out.println(this.name+"卖票---->"+(this.ticket--));  
13.             }  
14.         }  
15.     }  
16. }  
17. public class ThreadDemo {  
18.   
19.       
20.     public static void main(String[] args) {  
21.         MyThread mt1= new MyThread("一号窗口");  
22.         MyThread mt2= new MyThread("二号窗口");  
23.         MyThread mt3= new MyThread("三号窗口");  
24.         mt1.start();  
25.         mt2.start();  
26.         mt3.start();  
27.     }  
28.   
29. }  

运行结果：

1. 一号窗口卖票---->10  
2. 一号窗口卖票---->9  
3. 二号窗口卖票---->10  
4. 一号窗口卖票---->8  
5. 一号窗口卖票---->7  
6. 一号窗口卖票---->6  
7. 三号窗口卖票---->10  
8. 一号窗口卖票---->5  
9. 一号窗口卖票---->4  
10. 一号窗口卖票---->3  
11. 一号窗口卖票---->2  
12. 一号窗口卖票---->1  
13. 二号窗口卖票---->9  
14. 二号窗口卖票---->8  
15. 三号窗口卖票---->9  
16. 三号窗口卖票---->8  
17. 三号窗口卖票---->7  
18. 三号窗口卖票---->6  
19. 三号窗口卖票---->5  
20. 三号窗口卖票---->4  
21. 三号窗口卖票---->3  
22. 三号窗口卖票---->2  
23. 三号窗口卖票---->1  
24. 二号窗口卖票---->7  
25. 二号窗口卖票---->6  
26. 二号窗口卖票---->5  
27. 二号窗口卖票---->4  
28. 二号窗口卖票---->3  
29. 二号窗口卖票---->2  
30. 二号窗口卖票---->1 
    

通过实现Runnable接口

1. class MyThread1 implements Runnable{  
2.     private int ticket =10;  
3.     private String name;  
4.     public void run(){  
5.         for(int i =0;i<500;i++){  
6.             if(this.ticket>0){  
7.                 System.out.println(Thread.currentThread().getName()+"卖票---->"+(this.ticket--));  
8.             }  
9.         }  
10.     }  
11. }  
12. public class RunnableDemo {  
13.   
14.       
15.     public static void main(String[] args) {  
16.         // TODO Auto-generated method stub  
17.         //设计三个线程  
18.          MyThread1 mt = new MyThread1();  
19.          Thread t1 = new Thread(mt,"一号窗口");  
20.          Thread t2 = new Thread(mt,"二号窗口");  
21.          Thread t3 = new Thread(mt,"三号窗口");  
22.          t1.start();  
23.          t2.start();  
24.          t3.start();  
25.     }  
26.   
27. } 
    

运行结果：

1. 一号窗口卖票---->10  
2. 三号窗口卖票---->9  
3. 三号窗口卖票---->7  
4. 三号窗口卖票---->5  
5. 三号窗口卖票---->4  
6. 三号窗口卖票---->3  
7. 三号窗口卖票---->2  
8. 三号窗口卖票---->1  
9. 一号窗口卖票---->8  
10. 二号窗口卖票---->6
    

造成上面的差异的就是，继承Runnable接口的时候，new了一个 Thread1 ，然后通过三个线程来共享一个Thread1 ，这样三个进程就共享了资源int ticket =10; 

1. MyThread1 mt1 = new MyThread1();   
2. MyThread1 mt2 = new MyThread1();   
3. MyThread1 mt2 = new MyThread1();   
4. Thread t1 = new Thread(mt1,"一号窗口");    
5. Thread t2 = new Thread(mt2,"二号窗口");    
6. Thread t3 = new Thread(mt3,"三号窗口");  
   

这样的话， 就跟继承Thread类的结果是一样的了

总结一下，，实现Runable除了避免单继承的局限外，还有个好处就是能实现不同进程资源共享，而继承Thread没有这个功能。并不是这个特点是两者的绝对区别，继承Runable你可以选择不共享。