1. class Ticket implements Runnable
   
2. {
   
3.         private int tick=100;
   
4.         public void run()
   
5.         {
   
6.                 while(true)
   
7.                 {
   
8.                         if (tick>0)
   
9.                         {
   
10.                         System.out.println(Thread.currentThread().getName()+"sale..."+tick--);
    
11.                         }
    
12.                 }
    
13.         }
    
14. }
    
15. 
    
16. class ThreadDemo
    
17. {
    
18. public static void main (String []args)
    
19.         {
    
20.                 Ticket t = new Ticket();
    
21.                 Thread t1=new Thread(t);//此处为什么可以创建Thread的对象？貌似和Thread没有关系
    
22.                 Thread t2=new Thread(t);
    
23.                 Thread t3=new Thread(t);
    
24.                 Thread t4=new Thread(t);
    
25.                 t1.start();
    
26.                 t2.start();
    
27.                 t3.start();
    
28.                 t4.start();
    
29. 
    
30.         }
    
31. }
    
32. 
    

复制代码

线程的创建有两种方式，一种直接继承Thread，重写Run方法，一种实现Runnable接口，传进Thread类。
API中Thread的Run()的代码如下
    public void run() {
        if (target != null) {
            target.run();
        }
    }
target就是传进去的Ticket类

Thread是创建线程的类，传入参数t，让Thread的run使用t的run方法
必须调用start方法才能开启多线程
创建线程的两种方式实质都是改写run方法

创建线程有2中方法
        1.继承Thread类
                定义类继承Thread, 重写run()方法, 将线程中要执行的代码写在run()方法中
                创建该类对象, 调用start()方法就可以开启一条新线程, 新线程中自动指定run()方法
        2.实现Runnable接口
                定义类实现Runnable接口, 重写run()方法, 将线程中要执行的代码写在run()方法中
                创建该类对象, 创建Thread类对象, 将Runnable对象传入Thread的构造函数中
                调用Thread对象的start()方法就可以开启一条新线程, 新线程中执行Runnable的run()方法

为什么全部答非所问？

创建线程的第二种方式：实现Runnable接口。

步骤：
1，定义实现Runnable接口。
2，覆盖Runnable接口中的run方法。
        将线程要运行的代码存放在run方法种
3，通过Thread类建立线程对象。
4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
        为什么要将Runnable接口的子类对象传递给Thread的构造函数。
        因为，自定义的run方法所属的对象是Runnable接口的子类对象。
        所以要让线程去指定指定对象的run方法。
5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

怎么线程跟Threa类没有关系呢！
线程的启动需要本机操作系统的支持
public synchronized void start()
{
        if(threadStatus!=0)
        {
        throw new IllegalThreadStateException();
        ...
         }
        ...
        start0();
        ...
        }
        private native void start0();
上面的代码是Thread类中的start()方法，其实此方法正在启动的是start0()方法，start0()方法是用到了native关键字，此关键字是调用系统底层的

        所以启动线程必须要调用Thread类中的start()方法
你实现接口Runnable中没有此方法，但是Thread的构造方法中可以传入Runnable接口子类

在Thread类中有多个重载的构造方法
此处调用的是Thread(Runnable target) ，此构造函数的参数为一个Runnable接口类型的参数，但实质上接口是不能创建对象的，所以说此处肯定是用到了多态，此处肯定是传入一个实现了Runnable 类，事实上也就是这样做的。Ticket是实现了Runnable接口的类，
因此hread t1=new Thread(t);是完全没有问题的。
用Thread的构造方法创建Thread的类对象有什么不可以的呢？创建多个对象又有什么不可以呢？所以明显是没有问题的。
下面是Thread的构造函数：要更详细的请看java的API
Thread()        

Thread(Runnable target)
        
Thread(Runnable target, String name)
      
Thread(String name)
         
Thread(ThreadGroup group, Runnable target)
        
Thread(ThreadGroup group, Runnable target, String name)
         
Thread(ThreadGroup group, Runnable target, String name, long stackSize)
         
Thread(ThreadGroup group, String name)