两种方法 继承Thread类 和 实现Runnable接口

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

复制代码

既然实现Runnable接口的方法
     可以资源共享
     可以避免由于java的单继承机制带来的局限。
     可以再继承其他类的同时，还能实现多线程的功能

那么什么时候用Thread比较好？


只用实现Runnable接口的方法可以吗？

实现Runnable接口相对于继承Thread类来说，有几个显著的优势：
1.适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU同程序的代码，数据有效分离，较好体现了面向对象的设计思想。
2.可以避免由于java的单继承特性带来的局限。
3.增强了程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。

对于你提的问题，只用实现Runnable接口的方法是可以的，事实上，几乎所有的多线程都是使用实现Runnable接口的方式。

Java中有两种实现多线程的方式。一是直接继承Thread类，二是实现Runnable接口。那么这两种实现多线程的方式在应用上有什么区别呢？

继承Thread：一个线程对象只能启动一个线程，无论你调用多少遍start()方法，结果只有一个线程。

实现Runnable：创建了四个线程， 每个线程调用的是同一个ThreadTest对象中的run()方法，访问的是同一个对象中的变量（tickets）的实例。

实现Runnable接口相对于继承Thread类来说，有如下显著的好处：  
(1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU（线程）同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。  
(2)可以避免由于Java的单继承特性带来的局限。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中， 由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了 。  
(3)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象是，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。