線程的兩種創建方式及優劣比較
1、通過實現Runnable接口線程創建
(1).定義一個類實現Runnable接口，重寫接口中的run()方法。在run()方法中加入具體的任務代碼或處理邏輯。
(2).創建Runnable接口實現類的對象。
(3).創建一個Thread類的對象，需要封裝前面Runnable接口實現類的對象。（接口可以實現多繼承）
(4).調用Thread對象的start()方法，啟動線程
示例代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package demo.thread; public class TreadDemo1 implements Runnable { private int countDown = 10; @Override // 在run方法中定義任務 public void run() { while (countDown-- > 0) { System.out.println("#" + Thread.currentThread().getName() + "(" + countDown + ")"); } } public static void main(String[] args) { // Runnable中run方法是一個空方法，并不會產生任何線程行為，必須顯式地將一個任務附著到線程上 TreadDemo1 tt=new TreadDemo1(); new Thread(tt).start(); new Thread(tt).start(); System.out.println("火箭發射前倒計時："); } } |
運行結果：
火箭發射前倒計時：
|
1
2
3
4
5
6
7
8
9
10
|
#Thread-1(8)#Thread-1(7)#Thread-1(6)#Thread-1(5)#Thread-1(4)#Thread-1(3)#Thread-1(2)#Thread-1(1)#Thread-1(0)#Thread-0(9) |
2、通過繼承Thread類創建線程
(1).首先定義一個類去繼承Thread父類，重寫父類中的run()方法。在run()方法中加入具體的任務代碼或處理邏輯。
(2).直接創建一個ThreadDemo2類的對象，也可以利用多態性，變量聲明為父類的類型。
(3).調用start方法，線程t啟動，隱含的調用run()方法。
示例代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package demo.thread; public class ThreadDemo2 extends Thread { private int countDown = 10; @Override // 在run方法中定義任務 public void run() { while (countDown-- > 0) { System.out.println("#" + this.getName() + "(" + countDown + ")"); } } public static void main(String[] args) { new ThreadDemo2().start(); new ThreadDemo2().start(); // 由于start方法迅速返回，所以main線程可以執行其他的操作,此時有兩個獨立的線程在并發運行 System.out.println("火箭發射前倒計時："); } } |
運行結果：
|
1
2
3
4
5
6
7
8
9
10
|
#Thread-0(9)#Thread-0(8)#Thread-0(7)#Thread-0(6)#Thread-0(5)#Thread-0(4)#Thread-0(3)#Thread-0(2)#Thread-0(1)#Thread-0(0) |
火箭發射前倒計時：
|
1
2
3
4
5
6
7
8
9
10
|
#Thread-1(9)#Thread-1(8)#Thread-1(7)#Thread-1(6)#Thread-1(5)#Thread-1(4)#Thread-1(3)#Thread-1(2)#Thread-1(1)#Thread-1(0) |
3、兩種方式的比較
首先分析兩種方式的輸出結果，同樣是創建了兩個線程，為什么結果不一樣呢？
使用實現Runnable接口方式創建線程可以共享同一個目標對象 （TreadDemo1 tt=new TreadDemo1();），實現了多個相同線程處理同一份資源。
然后再看一段來自JDK的解釋：
Runnable 接口應該由那些打算通過某一線程執行其實例的類來實現。類必須定義一個稱為run 的無參數方法。
設計該接口的目的是為希望在活動時執行代碼的對象提供一個公共協議。例如，Thread 類實現了Runnable 。激活的意思是說某個線程已啟動并且尚未停止。
此外，Runnable 為非 Thread 子類的類提供了一種激活方式。通過實例化某個Thread 實例并將自身作為運行目標，就可以運行實現 Runnable 的類而無需創建 Thread 的子類。大多數情況下，如果只想重寫run() 方法，而不重寫其他 Thread 方法，那么應使用 Runnable 接口。這很重要，因為除非程序員打算修改或增強類的基本行為，否則不應為該類創建子類。
采用繼承Thread類方式：
（1）優點：編寫簡單，如果需要訪問當前線程，無需使用Thread.currentThread()方法，直接使用this，即可獲得當前線程。
（2）缺點：因為線程類已經繼承了Thread類，所以不能再繼承其他的父類。
采用實現Runnable接口方式：
（1）優點：線程類只是實現了Runable接口，還可以繼承其他的類。在這種方式下，可以多個線程共享同一個目標對象，所以非常適合多個相同線程來處理同一份資源的情況，從而可以將CPU代碼和數據分開，形成清晰的模型，較好地體現了面向對象的思想。
（2）缺點：編程稍微復雜，如果需要訪問當前線程，必須使用Thread.currentThread()方法。
后臺線程(守護線程)
所謂的后臺線程，是指在程序運行的時候在后臺提供一種通用服務的線程，并且這種線程并不屬于程序中不可或缺的部分。因此當所有的非后臺線程結束時，程序也就終止了，同時會殺死所有后臺線程。反過來說，只要有任何非后臺線程(用戶線程)還在運行，程序就不會終止。后臺線程在不執行finally子句的情況下就會終止其run方法。后臺線程創建的子線程也是后臺線程。 下面是一個后臺線程的示例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
package demo.thread; import java.util.concurrent.TimeUnit; public class DaemonDemo implements Runnable { @Override public void run() { try { while (true) { Thread.sleep(1000); System.out.println("#" + Thread.currentThread().getName()); } } catch (InterruptedException e) { e.printStackTrace(); } finally {// 后臺線程不執行finally子句 System.out.println("finally "); } } public static void main(String[] args) { for (int i = 0; i < 10; i++) { Thread daemon = new Thread(new DaemonDemo()); // 必須在start之前設置為后臺線程 daemon.setDaemon(true); daemon.start(); } System.out.println("All daemons started"); try { TimeUnit.MILLISECONDS.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } |
運行結果：
|
1
2
3
4
5
6
7
8
9
10
11
|
All daemons started#Thread-2#Thread-3#Thread-1#Thread-0#Thread-9#Thread-6#Thread-8#Thread-5#Thread-7#Thread-4 |
分析：從結果可以看出，十個子線程并沒有無線循環的打印，而是在主線程(main())退出后，JVM強制關閉所有后臺線程。而不會有任何希望出現的確認形式，如finally子句不執行。
