java线程的两种创建方式

http://blog.csdn.net/touch_2011/article/details/6891026

1、通过实现Runnable接口线程创建

(1).定义一个类实现Runnable接口，重写接口中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。

(2).创建Runnable接口实现类的对象。

(3).创建一个Thread类的对象，需要封装前面Runnable接口实现类的对象。（接口可以实现多继承）

(4).调用Thread对象的start()方法，启动线程

示例代码：

1. <span style="font-size:16px;">package demo.thread;  
2.   
3. public class TreadDemo1 implements Runnable {  
4.     private int countDown = 10;  
5.     @Override  
6.     // 在run方法中定义任务  
7.     public void run() {  
8.         while (countDown-- > 0) {  
9.             System.out.println("#" + Thread.currentThread().getName() + "("  
10.                     + countDown + ")");  
11.         }  
12.     }  
13.   
14.     public static void main(String[] args) {  
15.         // Runnable中run方法是一个空方法，并不会产生任何线程行为，必须显式地将一个任务附着到线程上  
16.         TreadDemo1 tt=new TreadDemo1();  
17.         new Thread(tt).start();  
18.         new Thread(tt).start();  
19.         System.out.println("倒计时：");  
20.     }  
21. }  
22. </span> 
    

运行结果：

倒计时：
#Thread-0(8)
#Thread-0(7)
#Thread-0(6)
#Thread-1(5)
#Thread-1(4)
#Thread-0(4)
#Thread-1(3)
#Thread-1(1)
#Thread-1(0)
#Thread-0(2)

2、通过继承Thread类创建线程

(1).首先定义一个类去继承Thread父类，重写父类中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。
(2).直接创建一个ThreadDemo2类的对象，也可以利用多态性，变量声明为父类的类型。

(3).调用start方法，线程t启动，隐含的调用run()方法。

示例代码：

[java] view plaincopy

1. <span style="font-size:16px;">package demo.thread;  
2.   
3. public class ThreadDemo2 extends Thread {  
4.     private int countDown = 10;  
5.   
6.     @Override  
7.     // 在run方法中定义任务  
8.     public void run() {  
9.         while (countDown-- > 0) {  
10.             System.out.println("#" + this.getName() + "(" + countDown + ")");  
11.         }  
12.     }  
13.   
14.     public static void main(String[] args) {  
15.         new ThreadDemo2().start();  
16.         new ThreadDemo2().start();  
17.         // 由于start方法迅速返回，所以main线程可以执行其他的操作,此时有两个独立的线程在并发运行  
18.         System.out.println("倒计时：");  
19.     }  
20. }  
21. </span>  

运行结果：

倒计时：
#Thread-0(9)
#Thread-0(8)
#Thread-0(7)
#Thread-1(9)
#Thread-0(6)
#Thread-1(8)
#Thread-0(5)
#Thread-1(7)
#Thread-0(4)
#Thread-1(6)
#Thread-0(3)
#Thread-0(2)
#Thread-0(1)
#Thread-0(0)
#Thread-1(5)
#Thread-1(4)
#Thread-1(3)
#Thread-1(2)
#Thread-1(1)
#Thread-1(0)

采用继承Thread类方式：
（1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。
（2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。
采用实现Runnable接口方式：
（1）优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
（2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。