Java多线程——实现方式

在Java中, 多线程的实现有两种方式：
扩展java.lang.Thread类
实现java.lang.Runnable接口

1、继承Thread类实现多线程
       继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：

[java]  view plain copy print ?

1. /** 
2.  * @Description: 继承Thread类, 实现多线程. 
3.  */  
4. package com.lian.thread;  
5.   
6. import org.apache.log4j.Logger;  
7.   
8. public class MyThread extends Thread {  
9.     private static Logger logger = Logger.getLogger(MyThread .class);  
10.     private int num = 5;
11.   
12.     public static void main(String[] args) {  
13.         MyThread t1 = new MyThread();  
14.         MyThread t2 = new MyThread(); 
15.         MyThread t3 = new MyThread(); 
16.         t1.start();//start为线程入口，通过它启动线程；直接调用run就变成了普通方法，没有加入到线程中
17.         t2.start();
18.         t3.start();
    
19.     }  
20.       
21.     public void run() {   
22.       for(int i=0;i<100;i++){
23.         if(num>0){
24.            // 获取当前线程的对象的方法是: Thread.currentThread()  
25.            System.out.println(Thread.currentThread().getName() + "买票" + (num --));
26.         }
27.       }
28.     }  
29. }  

输出结果：
Thread-2卖票5
Thread-2卖票4
Thread-2卖票3
Thread-2卖票2
Thread-2卖票1
Thread-1卖票5
Thread-1卖票4
Thread-1卖票3
Thread-1卖票2
Thread-1卖票1
Thread-3卖票5
Thread-3卖票4
Thread-3卖票3
Thread-3卖票2
Thread-3卖票1

2、实现Runnable接口方式实现多线程

[java]  view plain copy print ?

1. /** 
2.  * @Description: 测试Runnable类实现的多线程程序
3.  */  
4. package com.lian.thread;  
5.   
6. import org.apache.log4j.Logger;  
7.   
8. public class TestRunnable {  
9.     private static Logger logger = Logger.getLogger(MyRunnable .class);  
10.   
11.     public static void main(String[] args) {  
12.         // 1. 将任务处理代码移到实现了Runnable接口的类的run方法中。  
13.         // 2. 创建任务类的一个对象  
14.         // 3. 由Runnable创建Thread对象  
15.         // 4. 启动线程  
16.         MyRunnable r = new MyRunnable();  
17.         Thread r1 = new Thread(r, "A"); 
18.         Thread r2 = new Thread(r, "B");
19.         Thread r3 = new Thread(r, "C");  
20.   
21.         r1.start();  
22.         r2.start();  
23.         r3.start(); 
24.     }  
25. }  
26.   
27. class MyRunnable implements Runnable {  
28.     private int num = 5;
29.     // 当线程目标run()方法结束时该线程完成。  
30.     public void run() {  
31.         for (int i = 0; i < 100; i++) {   
32.             if(num > 0){
33.                System.out.println(Thread.currentThread().getName() + "买票" + (num --));  
34.             }
35.         }  
36.     }  
37. }  

输出结果：
A买票5
C买票3
B买票4
C买票1
A买票2

总结：
通过Rannable接口实现接口有如下的好处：
（1）适合于多个相同的程序代码的线程去处理同一资源。
（2）可以避免由于单继承带来的局限。
（3）增强了程序的健壮性，代码能够被多个线程共享，代码和数据独立。

共同点：

不论用哪种方法，都必须用Thread（如果是Thead子类就用它本身）产生线程，然后再调用start()方法。

不同点：

1、继承Thread类有一个缺点就是单继承，而实现Runnable接口则弥补了它的缺点，可以实现多继承

2、继承Thread类如果产生Thread实例对象，就必须产生多个Thread实例对象，然后再用Thread产生多个线程；而实现Runnable接口，只需要建立一个实现这个类的实例，然后用这一个实例对象产生多个线程。即实现了资源的共享性

基于以上两点所以建议用第二种方法