为什么要有两种创建线程的方式，一个Thread类不够吗？？
这是第一种线程创建方式：

1. class Thr extends Thread
   
2. {
   
3.         public void run()
   
4.         {
   
5.                 for(int i=0;i<100;i++)
   
6.                 {
   
7.                         System.out.println(this.getName()+"~~~~~~~run"+i);
   
8.                 }
   
9.         }
   
10. }
    
11. class ThreadDemo
    
12. {
    
13.         public static void main(String[] arge)
    
14.         {
    
15.                 Thr a = new Thr();
    
16.                 Thr b = new Thr();
    
17.                 a.start();
    
18.                 b.start();
    
19.                 for(int i=0;i<100;i++)
    
20.                 {
    
21.                         System.out.println("Hello World");
    
22.                 }
    
23.         }
    
24. }

复制代码

这是第二种：

1. <p>class Ticket implements Runnable//创建Ticket类并实现Runnable接口
   
2. {
   
3.         public int ticket = 100;
   
4.         Object a = new Object();
   
5.         public void run()//实现Runnable接口的run()方法
   
6.         {
   
7.                 while(true)
   
8.                 {
   
9.                         if(ticket>0)
   
10.                         {
    
11.                                 System.out.println(Thread.currentThread().getName()+"~~~~~~"+ticket--);
    
12.                         }
    
13.                         
    
14.                 }
    
15.         }
    
16. }
    
17. class TicketDemo
    
18. {
    
19.         public static void main(String[] arge)
    
20.         {
    
21.                
    
22.                 Ticket t = new Ticket();//创建Ticket类对象
    
23.                 Thread a1 = new Thread(t);//将Ticket类对象作为参数传入Thread类对象
    
24.                 Thread a2 = new Thread(t);
    
25.                 Thread a3 = new Thread(t);
    
26.                 a1.start();
    
27.                 a2.start();
    
28.                 a3.start();
    
29.         }
    
30. }
    
31. </p>

复制代码

      第一种线程方式是继承Thread类，java只支持单继承，如果你写了一个类，它要有线程，但又需要别的类的功能，需要继承，

这时候你就纠结了。  第二种方式可以实现接口，在实现接口的同时还能继承，还可以实现多个接口，解决了第一种方式的弊端。

                  
         实现方式的好处，避免了单继承的局限性，在定义线程的时候，建议使用实现方式。

        

Thread是继承，Runnable是接口。
在java里面只能实现单继承，也就是说你创建了一个类，那么它就只能继承一个类，如果这时你想要继承多线程的同时还必须要继承别的类，那么就不能实现了。但接口是可以多实现的。你的类可以继承一个类的同时实现多个接口。Thread有什么用？  Runnable没有构造方法，Thread才有构造方法！
所以说创建多线程最好用实现接口的方法。

创建线程有两种方法，一个是实现Runnable接口，一个是结成Thread类
实现方式和继承方式的区别是：
1实现方式好处在于避免了单继承的局限性。在定义线程时，建议使用实现方式。
2继承Thread线程代码存放在Thread子类的run方法中。
3实现Runnable线程代码存放在接口的子类的run方法中。

不知道是谁说过的，一个问题至少有十五种解决方法，这两种方式都是不同的，在java里面没有多继承，但是可以通过实现接口来实现这种需求。