Runnable可以实现资源共享但Thread不能实现资源共享的原因

转自:http://blog.csdn.net/javaniceyou/article/details/6859305

线程的两种实现方式，通过实现Runnable接口的线程方式可以实现资源的共享，而继承Thread则不可以，原因何在？先看下面两段代码：

通过Thread实现线程：

Java代码 

1. //使用Thread实现线程不能实现资源共享 

[java]  view plain copy

1. //使用Thread实现线程不能实现资源共享  
2. class MyThread extends Thread  
3. {     
4.     private int ticket=5;  
5.     private String name;  
6.     public MyThread(String name ){  
7.         this.name=name;  
8.     }  
9.     public void run(){  
10.         for(int i=0;i<10;i++){  
11.             if(ticket>5){  
12.                 System.out.println("线程"+name+"卖票"+i);  
13.             }  
14.         }  
15.       
16.     }  
17. }  
18.   
19. public class ThreadDemo02  
20. {  
21.     public static void main(String args[]){  
22.         MyThread A = new MyThread("A");    
23.         MyThread B = new MyThread("B");  
24.         A.start();  
25.         B.start();  
26.     }  
27. }  

通过Runnable实现：

Java代码 

1.  
   [java]  view plain copy

   1. //使用Runnable实现线程可以实现资源共享  
   2. class MyThread implements Runnable  
   3. {  
   4.     private int ticket=5;  
   5.     private String name;  
   6.     public MyThread(String name){  
   7.         this.name=name;  
   8.     }  
   9.     public void run(){  
   10.         for(int i=1;i<=10;i++){  
   11.             if(ticket>0){  
   12.                 System.out.println("线程"+name+"卖票"+(ticket--));  
   13.                 }  
   14.         }  
   15.     }  
   16. }  
   17. public class RunnableDemo02  
   18. {  
   19.     public static void main(String args[]){  
   20.         MyThread A = new MyThread("A");  //实例化线程要执行的任务  
   21.         Thread Ta = new Thread(A);    //实例两个线程对象，实际传递的是一个任务  
   22.         Thread Tb = new Thread(A);    //因为两个线程执行的是一个任务，所以资源是共享的  
   23.         Ta.start();  
   24.         Tb.start();  
   25.     }  
   26. }  

解释：

因为一个线程只能启动一次，通过Thread实现线程时，线程和线程所要执行的任务是捆绑在一起的。也就使得一个任务只能启动一个线程，不同的线程执行的任务是不相同的，所以没有必要，也不能让两个线程共享彼此任务中的资源。

一个任务可以启动多个线程，通过Runnable方式实现的线程，实际是开辟一个线程，将任务传递进去，由此线程执行。可以实例化多个 Thread对象，将同一任务传递进去，也就是一个任务可以启动多个线程来执行它。这些线程执行的是同一个任务，所以他们的资源是共享。

两种不同的线程实现方式本身就决定了其是否能进行资源共享。