大家都知道多线程可以通过两种方式来创建。
一、通过继承Thread类
二、通过实现Runnable接口
那么中两种方式到底有什么区别呢？那种方式更好些呢？
我们使用多线程，无非就是想利用多线程的优点，来更好的实现我们的想法。
多线程有哪些优点呢？
一、多线程共享同一块内存空间和一组系统资源
二、线程本身的数据通常都是只有微处理器的寄存器数据，以及供程序执行的堆栈。所以系统在产生一个线程或者线程的切换要比进程系统的负担小很多。
现在我们来了解一些Thread类。

1. public class ThreadDemo
   
2. {   
   
3.     public static void main(String []args)   
   
4.     {   
   
5.         ThreadTest t=new ThreadTest();   
   
6.         t.start();   
   
7.         t.start();   
   
8.         t.start();   
   
9.         t.start();   
   
10.     }   
    
11. }   
    
12. class ThreadTest extends Thread   
    
13. {   
    
14.     private int count=10;   
    
15.     public void run()   
    
16.     {   
    
17.         while(count>0)   
    
18.         {   
    
19.             System.out.println(Thread.currentThread().getName()+"   "+count--);   
    
20.         }   
    
21.     }   
    
22. }

复制代码

运行后，我们发现其实只启动了一个线程。
是不是程序有问题呢？我们修改一下程序。

1. public  class ThreadDemo   
   
2. {   
   
3.     public static void main(String []args)   
   
4.     {   
   
5.         new ThreadTest().start();   
   
6.         new ThreadTest().start();   
   
7.         new ThreadTest().start();   
   
8.         new ThreadTest().start();   
   
9.     }   
   
10. }   
    
11. class ThreadTest extends Thread   
    
12. {   
    
13.     private int count=10;   
    
14.     public void run()   
    
15.     {   
    
16.         while(count>0)   
    
17.         {   
    
18.             System.out.println(Thread.currentThread().getName()+"   "+count--);   
    
19.         }   
    
20.     }   
    
21. }

复制代码

再次运行，发现这四个线程对象各自占有各自的资源，并不是同时完成统一任务。
我们可以得出结论：Thread类实际上无法达到资源共享的目的。
那么，Runnable接口能不能达到这一目的呢？
我们大可试一下。

1. public  class ThreadDemo   
   
2. {   
   
3.     public static void main(String []args)   
   
4.     {   
   
5.         ThreadTest test=new ThreadTest();   
   
6.         new Thread(test).start();   
   
7.         new Thread(test).start();   
   
8.         new Thread(test).start();   
   
9.         new Thread(test).start();   
   
10.     }   
    
11. }   
    
12. class ThreadTest implements Runnable   
    
13. {   
    
14.     private int count=10;   
    
15.     public void run()   
    
16.     {   
    
17.         while(count>0)   
    
18.         {   
    
19.             System.out.println(Thread.currentThread().getName()+"   "+count--);   
    
20.         }   
    
21.     }   
    
22. }

复制代码

运行之后我们发现，这四个线程同时完成了我们需要完成的任务。
通过以上比较我们即可得出Thread与Runnable的区别：
1、Runnable适合于多个相同程序代码线程去处理统一资源的情况，把虚拟的cpu（线程）同程序的代码，数据有效分离，较好体现面向对象的编程的思想
2、Runnable可以避免由于java的单继承机制带来的局限。可以再继承其他类的同时，还能实现多线程的功能。
3、Runnable能增加程序的健壮性。代码能够被多个线程共享。

thread也可以做，把private  static int count=10; 就可以共享数据，第一个程序如果想要开启4个线程是错误的，你写的是对同一线程4次开启，不是同时开启4个线程，thread代码简单，但是如果一个类有父类就不能用了，但是可以实现runnable来开启线程，用thread要开启4个线程 必须new四次ThreadTest，runnable ，new一次就行，但是不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码相对来说较复杂。。

创建Thread类调用start()方法开启线程也可以做到数据共享，如你上面的代码，只要把count用static修饰就可以了，但是被static修饰的变量生命周期太长，所以不提倡。
而实现Runnable接口并复写run()方法，也是通过创建Thread类对象调用start()方法来开启线程，只是把实现Runnable接口的类的对象作为参数传递给Thread对象，从而实现了java中单继承的局限性。
而上面的代码之所以做到了数据的共享是因为你只是建立了一个Runnable子类的对象，把他传递给了四个线程，从而做到了数据的共享。

实现方式（Runnable）和继承方式（Thread）的区别？

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

两种方式的区别：
继承Thread：线程代码存放在Thread子类的run方法中，
                        而且因为java是支持单继承。所以使用Thread类局限性很大。
实现Runnable，线程代码存放在接口的子类的run方法中。
                       使用Runnable接口，避免了单继承的局限性。增强了扩展性