1. /*

复制代码

这个是利用Runnable方法使用多线程。避免了单继承的局限性，代码是放在接口的子类run方法中。

1. class Test extends Thread
   
2. {
   
3.         private static int piao = 100;
   
4.         public void run()
   
5.         {
   
6.                 while(piao>0)
   
7.                 {
   
8.                         piao--;
   
9.                         System.out.println(Thread.currentThread().getName()+"卖票啦，还有："+piao+"张");
   
10.                 }
    
11.         }
    
12. }
    
13. 
    
14. class ThreadTest
    
15. {
    
16.         public static void main(String[] args)
    
17.         {       
    
18.                 Test p1 = new Test();
    
19.                 Test p2 = new Test();
    
20.                 Test p3 = new Test();
    
21.                
    
22.                 p1.start();
    
23.                 p2.start();
    
24.                 p3.start();
    
25.         }
    
26. }

复制代码

这是利用Thread方法卖票。这样的话需要将 piao 静态修饰才能共享。
在这里有一个疑问：
        p1 p2 p3 到底是指向一个run方法
        还是在方法区开辟了3个空间，分别指向各自的方法
按照我的想法是在方法区开辟了各自的空间，再其调用。
这样的话使用Runnable会比Thread好。
会节省空间资源。

class Test implements Runnable
{
        private int piao = 100;
        public void run()
        {
                while(piao>0)
                {
                        piao--;
                        System.out.println(Thread.currentThread().getName()+"卖票啦，还有："+piao+"张");
                }
        }
}

class ThreadDemo
{
        public static void main(String[] args)
        {
                Test t = new Test();
               
                Thread p1 = new Thread(t);
                Thread p2 = new Thread(t);
                Thread p3 = new Thread(t);
               
                p1.start();
                p2.start();
                p3.start();
        }
}
这个是利用Runnable方法使用多线程。避免了单继承的局限性，代码是放在接口的子类run方法中

Runnable的优点就是能数据共享。而thread局限性太大。