想知道用如下两种方法创建的线程共享变量时，有没有什么不同？或是哪一种好一些？
方法1，继承Thread类,使用静态变量：

1. public static void main（String [] args）{
   
2.     MutliThread m1=new MutliThread（"Window 1"）；
   
3.     MutliThread m2=new MutliThread（"Window 2"）；
   
4.     m1.start（）；
   
5.     m2.start（）；
   
6.     }
   
7. class MutliThread extends Thread{
   
8.     private static int ticket=100;//共享变量
   
9.     public void run（）{
   
10.        while（ticket>0）{
    
11.             System.out.println（ticket--+" is saled by "+Thread.currentThread（）.getName（））；
    
12.        }
    
13.     }
    
14. }

复制代码

方法2，实现Runnable接口：

1. public static void main（String [] args）{
   
2.     MutliThread m1=new MutliThread（"Window 1"）；
   
3.     MutliThread m2=new MutliThread（"Window 2"）；
   
4. 
   
5.     Thread t1=new Thread（m1）；
   
6.     Thread t2=new Thread（m2）；
   
7. 
   
8.     t1.start（）；
   
9.     t2.start（）；
   
10.     }
    
11. class MutliThread implements Runnable{
    
12.     private int ticket=100;//共享变量
    
13.     public void run（）{
    
14.        while（ticket>0）{
    
15.             System.out.println（ticket--+" is saled by "+Thread.currentThread（）.getName（））；
    
16.        }
    
17.     }
    
18. }

复制代码

当然实现Runnable接口，，因为java类不支持多继承关系，如果一个类继承了Thread，那这个类就不能再继承其他类，但java中支持多实现，一个类可以同时实现N个接口，所以实现Runnable接口是最完美的

楼上的话我就不重复了，如果是共享数据的话，还是用倾向于用Runnable接口的实现类好，如果用继承Thread的类,在变换静态变量时，以前用过该类的所有线程都会发生变化，不可控。

楼上说的对，java只能单继承，因此如果是采用继承Thread的方法，那么在以后进行代码重构的时候可能会遇到问题，因为你无法继承别的类了，在其他的方面，两者之间并没什么太大的区别。

如楼上两位同仁说的 由于java中类的基础具有单继承性，
例如
MutliThread继承Thread后就不能继承其他类， 但是有时候需要继承其他类，例如
student应该继承Person类，但是student类中的一部分代码需要用多线程执行，所以student要继承Thread，
但是student已经继承了Person，所以这时就不能继承Thread了。
这时就用到了第二种创建进程的方法，即声明实现 Runnable 接口的类
对于实现方式和继承方式有什么区别呢？
实现方式好处：避免单继承的局限性
    定义线程时，建议使用实现方式。

如果问题未解决，请继续追问，如果问题解决了，请将问题分类改为“已解决”，谢谢