Java中Runnable和Thread的区别

在Java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口。
Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。
一、使用Thread方式启动多线程：

Java代码

1. class MyThread extends Thread{    
2.     private String name;    
3.     public MyThread(String name) {    
4.         super();    
5.         this.name = name;    
6.     }    
7.     public void run(){    
8.         for(int i=0;i<10;i++){    
9.             System.out.println("线程开始："+this.name+",i="+i);    
10.         }    
11.     }    
12. }    
13. public class ThreadDemo01 {    
14.     public static void main(String[] args) {    
15.         MyThread mt1=new MyThread("线程a");    
16.         MyThread mt2=new MyThread("线程b");    
17.         mt1.run();    
18.         mt2.run();    
19.     }    
20. }   

运行结果：
Thread Run:Thread A,i=0
Thread Run:Thread A,i=1
Thread Run:Thread A,i=2
Thread Run:Thread A,i=3
Thread Run:Thread A,i=4
Thread Run:Thread B,i=0
Thread Run:Thread B,i=1
Thread Run:Thread B,i=2
Thread Run:Thread B,i=3
Thread Run:Thread B,i=4
        不过此时运行的结果并不是我们所预料中的那样，而是先执行完线程A，然后再执行线程B。导致这样的结果是因为程序中使用了run方法启动线程，通过查找源代码：

Java代码

1. public void run() {  
2.     if (target != null) {  
3.         target.run();  
4.     }  
5. }  

        因为线程是跟操作系统相关的，run方法并没有操作系统相关的操作，所以也就不会产生多线程的结果啦。通过查看jdk文档可以发现start方法：当调用start方法时，JVM会调用run方法。下面使用start方法启动线程：

Java代码

1. public class ThreadDemo01 {    
2.     public static void main(String[] args) {    
3.         MyThread mt1=new MyThread("Thread A");    
4.         MyThread mt2=new MyThread("Thread B");    
5.         //mt1.run();    
6.         //mt2.run();    
7.         mt1.start() ;  
8.         mt2.start() ;  
9.     }    
10. }   

运行结果：
Thread Run:Thread A,i=0
Thread Run:Thread A,i=1
Thread Run:Thread B,i=0
Thread Run:Thread B,i=1
Thread Run:Thread B,i=2
Thread Run:Thread B,i=3
Thread Run:Thread A,i=2
Thread Run:Thread A,i=3
Thread Run:Thread A,i=4
Thread Run:Thread B,i=4
        可以看到此时线程A和线程B就并行执行了。
二、通过实现Runnable接口实现多线程
因为在Java中一个class只能继承一个父类，所以在实际开发中很少有使用到Thread，而是使用Runnable接口。

Java代码

1. class MyThread02 implements Runnable{    
2.     private String name;    
3.     public MyThread02(String name) {    
4.         this.name = name;    
5.     }  
6.     public void run(){    
7.         for(int i=0;i<100;i++){    
8.             System.out.println("Thread Run:"+this.name+",i="+i);    
9.         }    
10.     }    
11. }  
12. public class ThreadDemo02 {    
13.     public static void main(String[] args) {    
14.         MyThread mt1=new MyThread("Thread A");    
15.         MyThread mt2=new MyThread("Thread B");    
16.           
17.         new Thread(mt1).start() ;  
18.         new Thread(mt2).start() ;  
19.     }    
20. }   

运行结果：
Thread Run:Thread B,i=0
Thread Run:Thread B,i=1
Thread Run:Thread A,i=0
Thread Run:Thread B,i=2
Thread Run:Thread A,i=1
Thread Run:Thread B,i=3
Thread Run:Thread A,i=2
Thread Run:Thread A,i=3
Thread Run:Thread B,i=4
Thread Run:Thread A,i=4

两种实现方式的区别：
Thread方式：
 

•   通过继承Thread类
•   重写run方法
•   在main函数中通过new Thread子类，然后调用start方法开启多线程

Runnable方式：
 

•   通过实现接口Runnable
•   重写run方法
•   在main函数中通过new Thread传入Runnable对象，然后调用start方法开启多线程

        在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处：

• 避免单继承的局限，一个类可以继承多个接口。
• 适合于资源的共享

实例（以卖票程序为例Thread方式实现，系统中有5张票，每个线程相当于一个售票机）：

Java代码

1. public class MyThread03 extends Thread{    
2.     private String name ;  
3.     private int ticket=5;  
4.     public MyThread03(String name){  
5.         this.name = name ;  
6.     }  
7.     public void run(){    
8.         for(int i=0;i<20;i++){    
9.             if(this.ticket>0){    
10.                 System.out.println(name+"卖票，剩余:"+this.ticket--);    
11.             }    
12.         }    
13.     }    
14. }  
15. public class ThreadTicket {    
16.     public static void main(String[] args) {    
17.         Thread mt1=new MyThread03("Thread A");    
18.         Thread mt2=new MyThread03("Thread B");    
19.         Thread mt3=new MyThread03("Thread C");    
20.           
21.         mt1.start();  
22.         mt2.start();  
23.         mt3.start();  
24.     }    
25. }   

运行结果：
Thread A卖票，剩余:5
Thread C卖票，剩余:5
Thread B卖票，剩余:5
Thread C卖票，剩余:4
Thread A卖票，剩余:4
Thread C卖票，剩余:3
Thread B卖票，剩余:4
Thread C卖票，剩余:2
Thread A卖票，剩余:3
Thread A卖票，剩余:2
Thread C卖票，剩余:1
Thread B卖票，剩余:3
Thread A卖票，剩余:1
Thread B卖票，剩余:2
Thread B卖票，剩余:1
        从运行结果可以看出，此时三个售票机并没有共享5张票，而是各自买了5张票，这是不合理的。
实例（Runnable接口方式）：

Java代码

1. public class MyThread04 implements Runnable{   
2.     private int ticket=5;  
3.     public void run(){    
4.         for(int i=0;i<20;i++){    
5.             if(this.ticket>0){    
6.                 System.out.println(Thread.currentThread().getName() +"卖票，剩余:"+this.ticket--);    
7.             }    
8.         }    
9.     }    
10. }  
11. public class ThreadTicket02 {    
12.     public static void main(String[] args) {    
13.         Runnable rn=new MyThread04();    
14.           
15.         new Thread(rn,"Thread A").start();  
16.         new Thread(rn,"Thread B").start();  
17.         new Thread(rn,"Thread C").start();  
18.     }    
19. }   

运行结果：
Thread A卖票，剩余:5
Thread A卖票，剩余:2
Thread C卖票，剩余:3
Thread B卖票，剩余:4
Thread A卖票，剩余:1
        此时使用Runnable方法向三个Thread中传递同一个对象，即可实现资源的共享。当然此时剩余票数并没有顺序，因为此时并没有对程序进行同步处理，可在run方法中添加synchronized同步声明：

Java代码

1. public class MyThread04 implements Runnable{   
2.     private int ticket=5;  
3.     public synchronized void run(){    
4.         for(int i=0;i<20;i++){    
5.             if(this.ticket>0){    
6.                 System.out.println(Thread.currentThread().getName() +"卖票，剩余:"+this.ticket--);    
7.             }    
8.         }    
9.     }    
10. }  

运行结果：
Thread B卖票，剩余:5
Thread B卖票，剩余:4
Thread B卖票，剩余:3
Thread B卖票，剩余:2
Thread B卖票，剩余:1
        最后通过查看源代码可知道其实Thread已经实现了Runnable接口：class Thred implements Runnable。
        这是自己第一篇博客，语言组织方面没有那么完善，同时博客内容中有不少是从别的地方借鉴的，希望能够培养自己以后写博客的习惯，同时也能提高自己的能力。