在這篇文章里，我們關注多線程。多線程是一個復雜的話題，包含了很多內容，這篇文章主要關注線程的基本屬性、如何創建線程、線程的狀態切換以及線程通信。
線程是操作系統運行的基本單位，它被封裝在進程中，一個進程可以包含多個線程。即使我們不手動創造線程，進程也會有一個默認的線程在運行。
對于JVM來說，當我們編寫一個單線程的程序去運行時，JVM中也是有至少兩個線程在運行，一個是我們創建的程序，一個是垃圾回收。
線程基本信息
我們可以通過Thread.currentThread()方法獲取當前線程的一些信息，并對其進行修改。
我們來看以下代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
查看并修改當前線程的屬性String name = Thread.currentThread().getName(); int priority = Thread.currentThread().getPriority(); String groupName = Thread.currentThread().getThreadGroup().getName(); boolean isDaemon = Thread.currentThread().isDaemon(); System.out.println("Thread Name:" + name); System.out.println("Priority:" + priority); System.out.println("Group Name:" + groupName); System.out.println("IsDaemon:" + isDaemon); Thread.currentThread().setName("Test"); Thread.currentThread().setPriority(Thread.MAX_PRIORITY); name = Thread.currentThread().getName(); priority = Thread.currentThread().getPriority(); groupName = Thread.currentThread().getThreadGroup().getName(); isDaemon = Thread.currentThread().isDaemon(); System.out.println("Thread Name:" + name); System.out.println("Priority:" + priority); |
其中列出的屬性說明如下：
- GroupName，每個線程都會默認在一個線程組里，我們也可以顯式的創建線程組，一個線程組中也可以包含子線程組，這樣線程和線程組，就構成了一個樹狀結構。
- Name，每個線程都會有一個名字，如果不顯式指定，那么名字的規則是“Thread-xxx”。
- Priority，每個線程都會有自己的優先級，JVM對優先級的處理方式是“搶占式”的。當JVM發現優先級高的線程時，馬上運行該線程；對于多個優先級相等的線程，JVM對其進行輪詢處理。Java的線程優先級從1到10，默認是5，Thread類定義了2個常量：MIN_PRIORITY和MAX_PRIORITY來表示最高和最低優先級。
我們可以看下面的代碼，它定義了兩個不同優先級的線程：
|
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
|
線程優先級示例public static void priorityTest(){ Thread thread1 = new Thread("low") { public void run() { for (int i = 0; i < 5; i++) { System.out.println("Thread 1 is running."); } } }; Thread thread2 = new Thread("high") { public void run() { for (int i = 0; i < 5; i++) { System.out.println("Thread 2 is running."); } } }; thread1.setPriority(Thread.MIN_PRIORITY); thread2.setPriority(Thread.MAX_PRIORITY); thread1.start(); thread2.start();} |
從運行結果可以看出，是高優先級線程運行完成后，低優先級線程才運行。
isDaemon，這個屬性用來控制父子線程的關系，如果設置為true，當父線程結束后，其下所有子線程也結束，反之，子線程的生命周期不受父線程影響。
我們來看下面的例子：
|
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
|
IsDaemon 示例public static void daemonTest(){ Thread thread1 = new Thread("daemon") { public void run() { Thread subThread = new Thread("sub") { public void run() { for(int i = 0; i < 100; i++) { System.out.println("Sub Thread Running " + i); } } }; subThread.setDaemon(true); subThread.start(); System.out.println("Main Thread end."); } }; thread1.start();} |
上面代碼的運行結果，在和刪除subThread.setDaemon(true);后對比，可以發現后者運行過程中子線程會完成執行后再結束，而前者中，子線程很快就結束了。
如何創建線程
上面的內容，都是演示默認線程中的一些信息，那么應該如何創建線程呢？在Java中，我們有3種方式可以用來創建線程。
Java中的線程要么繼承Thread類，要么實現Runnable接口，我們一一道來。
使用內部類來創建線程
我們可以使用內部類的方式來創建線程，過程是聲明一個Thread類型的變量，并重寫run方法。示例代碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
使用內部類創建線程public static void createThreadByNestClass(){ Thread thread = new Thread() { public void run() { for (int i =0; i < 5; i++) { System.out.println("Thread " + Thread.currentThread().getName() + " is running."); } System.out.println("Thread " + Thread.currentThread().getName() + " is finished."); } }; thread.start();} |
繼承Thread以創建線程
我們可以從Thread中派生一個類，重寫其run方法，這種方式和上面相似。示例代碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
派生Thread類以創建線程class MyThread extends Thread{ public void run() { for (int i =0; i < 5; i++) { System.out.println("Thread " + Thread.currentThread().getName() + " is running."); } System.out.println("Thread " + Thread.currentThread().getName() + " is finished."); }}public static void createThreadBySubClass(){ MyThread thread = new MyThread(); thread.start();} |
實現Runnable接口以創建線程
我們可以定義一個類，使其實現Runnable接口，然后將該類的實例作為構建Thread變量構造函數的參數。示例代碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
實現Runnable接口以創建線程class MyRunnable implements Runnable{ public void run() { for (int i =0; i < 5; i++) { System.out.println("Thread " + Thread.currentThread().getName() + " is running."); } System.out.println("Thread " + Thread.currentThread().getName() + " is finished."); }}public static void createThreadByRunnable(){ MyRunnable runnable = new MyRunnable(); Thread thread = new Thread(runnable); thread.start();} |
上述3種方式都可以創建線程，而且從示例代碼上看，線程執行的功能是一樣的，那么這三種創建方式有什么不同呢？
這涉及到Java中多線程的運行模式，對于Java來說，多線程在運行時，有“多對象多線程”和“單對象多線程”的區別：
- 多對象多線程，程序在運行過程中創建多個線程對象，每個對象上運行一個線程。
- 單對象多線程，程序在運行過程中創建一個線程對象，在其上運行多個線程。
顯然，從線程同步和調度的角度來看，多對象多線程要簡單一些。上述3種線程創建方式，前兩種都屬于“多對象多線程”，第三種既可以使用“多對象多線程”，也可以使用“單對象單線程”。
我們來看下面的示例代碼，里面會用到Object.notify方法，這個方法會喚醒對象上的一個線程；而Object.notifyAll方法，則會喚醒對象上的所有線程。
|
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
notify示例public class NotifySample { public static void main(String[] args) throws InterruptedException { notifyTest(); notifyTest2(); notifyTest3(); } private static void notifyTest() throws InterruptedException { MyThread[] arrThreads = new MyThread[3]; for (int i = 0; i < arrThreads.length; i++) { arrThreads[i] = new MyThread(); arrThreads[i].id = i; arrThreads[i].setDaemon(true); arrThreads[i].start(); } Thread.sleep(500); for (int i = 0; i < arrThreads.length; i++) { synchronized(arrThreads[i]) { arrThreads[i].notify(); } } } private static void notifyTest2() throws InterruptedException { MyRunner[] arrMyRunners = new MyRunner[3]; Thread[] arrThreads = new Thread[3]; for (int i = 0; i < arrThreads.length; i++) { arrMyRunners[i] = new MyRunner(); arrMyRunners[i].id = i; arrThreads[i] = new Thread(arrMyRunners[i]); arrThreads[i].setDaemon(true); arrThreads[i].start(); } Thread.sleep(500); for (int i = 0; i < arrMyRunners.length; i++) { synchronized(arrMyRunners[i]) { arrMyRunners[i].notify(); } } } private static void notifyTest3() throws InterruptedException { MyRunner runner = new MyRunner(); Thread[] arrThreads = new Thread[3]; for (int i = 0; i < arrThreads.length; i++) { arrThreads[i] = new Thread(runner); arrThreads[i].setDaemon(true); arrThreads[i].start(); } Thread.sleep(500); synchronized(runner) { runner.notifyAll(); } }}class MyThread extends Thread{ public int id = 0; public void run() { System.out.println("第" + id + "個線程準備休眠5分鐘。"); try { synchronized(this) { this.wait(5*60*1000); } } catch(InterruptedException ex) { ex.printStackTrace(); } System.out.println("第" + id + "個線程被喚醒。"); }}class MyRunner implements Runnable{ public int id = 0; public void run() { System.out.println("第" + id + "個線程準備休眠5分鐘。"); try { synchronized(this) { this.wait(5*60*1000); } } catch(InterruptedException ex) { ex.printStackTrace(); } System.out.println("第" + id + "個線程被喚醒。"); } } |
示例代碼中，notifyTest()和notifyTest2()是“多對象多線程”，盡管notifyTest2()中的線程實現了Runnable接口，但是它里面定義Thread數組時，每個元素都使用了一個新的Runnable實例。notifyTest3()屬于“單對象多線程”，因為我們只定義了一個Runnable實例，所有的線程都會使用這個實例。
notifyAll方法適用于“單對象多線程”的情景，因為notify方法只會隨機喚醒對象上的一個線程。
線程的狀態切換
對于線程來講，從我們創建它一直到線程運行結束，在這個過程中，線程的狀態可能是這樣的：
- 創建：已經有Thread實例了， 但是CPU還有為其分配資源和時間片。
- 就緒：線程已經獲得了運行所需的所有資源，只等CPU進行時間調度。
- 運行：線程位于當前CPU時間片中，正在執行相關邏輯。
- 休眠：一般是調用Thread.sleep后的狀態，這時線程依然持有運行所需的各種資源，但是不會被CPU調度。
- 掛起：一般是調用Thread.suspend后的狀態，和休眠類似，CPU不會調度該線程，不同的是，這種狀態下，線程會釋放所有資源。
- 死亡：線程運行結束或者調用了Thread.stop方法。
下面我們來演示如何進行線程狀態切換，首先我們會用到下面方法：
- Thread()或者Thread(Runnable)：構造線程。
- Thread.start：啟動線程。
- Thread.sleep：將線程切換至休眠狀態。
- Thread.interrupt：中斷線程的執行。
- Thread.join：等待某線程結束。
- Thread.yield：剝奪線程在CPU上的執行時間片，等待下一次調度。
- Object.wait：將Object上所有線程鎖定，直到notify方法才繼續運行。
- Object.notify：隨機喚醒Object上的1個線程。
- Object.notifyAll：喚醒Object上的所有線程。
下面，就是演示時間啦?。。?/p>
線程等待與喚醒
這里主要使用Object.wait和Object.notify方法，請參見上面的notify實例。需要注意的是，wait和notify都必須針對同一個對象，當我們使用實現Runnable接口的方式來創建線程時，應該是在Runnable對象而非Thread對象上使用這兩個方法。
線程的休眠與喚醒
|
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
|
Thread.sleep實例public class SleepSample { public static void main(String[] args) throws InterruptedException { sleepTest(); } private static void sleepTest() throws InterruptedException { Thread thread = new Thread() { public void run() { System.out.println("線程 " + Thread.currentThread().getName() + "將要休眠5分鐘。"); try { Thread.sleep(5*60*1000); } catch(InterruptedException ex) { System.out.println("線程 " + Thread.currentThread().getName() + "休眠被中斷。"); } System.out.println("線程 " + Thread.currentThread().getName() + "休眠結束。"); } }; thread.setDaemon(true); thread.start(); Thread.sleep(500); thread.interrupt(); }} |
線程在休眠過程中，我們可以使用Thread.interrupt將其喚醒，這時線程會拋出InterruptedException。
線程的終止
雖然有Thread.stop方法，但該方法是不被推薦使用的，我們可以利用上面休眠與喚醒的機制，讓線程在處理IterruptedException時，結束線程。
|
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
|
Thread.interrupt示例public class StopThreadSample { public static void main(String[] args) throws InterruptedException { stopTest(); } private static void stopTest() throws InterruptedException { Thread thread = new Thread() { public void run() { System.out.println("線程運行中。"); try { Thread.sleep(1*60*1000); } catch(InterruptedException ex) { System.out.println("線程中斷，結束線程"); return; } System.out.println("線程正常結束。"); } }; thread.start(); Thread.sleep(500); thread.interrupt(); }} |
線程的同步等待
當我們在主線程中創建了10個子線程，然后我們期望10個子線程全部結束后，主線程在執行接下來的邏輯，這時，就該Thread.join登場了。
|
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
|
Thread.join示例public class JoinSample { public static void main(String[] args) throws InterruptedException { joinTest(); } private static void joinTest() throws InterruptedException { Thread thread = new Thread() { public void run() { try { for(int i = 0; i < 5; i++) { System.out.println("線程在運行。"); Thread.sleep(1000); } } catch(InterruptedException ex) { ex.printStackTrace(); } } }; thread.setDaemon(true); thread.start(); Thread.sleep(1000); thread.join(); System.out.println("主線程正常結束。"); }} |
我們可以試著將thread.join();注釋或者刪除，再次運行程序，就可以發現不同了。
線程間通信
我們知道，一個進程下面的所有線程是共享內存空間的，那么我們如何在不同的線程之間傳遞消息呢？在回顧 Java I/O時，我們談到了PipedStream和PipedReader，這里，就是它們發揮作用的地方了。
下面的兩個示例，功能完全一樣，不同的是一個使用Stream，一個使用Reader/Writer。
|
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
PipeInputStream/PipedOutpueStream 示例public static void communicationTest() throws IOException, InterruptedException{ final PipedOutputStream pos = new PipedOutputStream(); final PipedInputStream pis = new PipedInputStream(pos); Thread thread1 = new Thread() { public void run() { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); try { while(true) { String message = br.readLine(); pos.write(message.getBytes()); if (message.equals("end")) break; } br.close(); pos.close(); } catch(Exception ex) { ex.printStackTrace(); } } }; Thread thread2 = new Thread() { public void run() { byte[] buffer = new byte[1024]; int bytesRead = 0; try { while((bytesRead = pis.read(buffer, 0, buffer.length)) != -1) { System.out.println(new String(buffer)); if (new String(buffer).equals("end")) break; buffer = null; buffer = new byte[1024]; } pis.close(); buffer = null; } catch(Exception ex) { ex.printStackTrace(); } } }; thread1.setDaemon(true); thread2.setDaemon(true); thread1.start(); thread2.start(); thread1.join(); thread2.join();} |
|
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
|
PipedReader/PipedWriter 示例private static void communicationTest2() throws InterruptedException, IOException{ final PipedWriter pw = new PipedWriter(); final PipedReader pr = new PipedReader(pw); final BufferedWriter bw = new BufferedWriter(pw); final BufferedReader br = new BufferedReader(pr); Thread thread1 = new Thread() { public void run() { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); try { while(true) { String message = br.readLine(); bw.write(message); bw.newLine(); bw.flush(); if (message.equals("end")) break; } br.close(); pw.close(); bw.close(); } catch(Exception ex) { ex.printStackTrace(); } } }; Thread thread2 = new Thread() { public void run() { String line = null; try { while((line = br.readLine()) != null) { System.out.println(line); if (line.equals("end")) break; } br.close(); pr.close(); } catch(Exception ex) { ex.printStackTrace(); } } }; thread1.setDaemon(true); thread2.setDaemon(true); thread1.start(); thread2.start(); thread1.join(); thread2.join();} |
感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！
原文鏈接：http://www.cnblogs.com/wing011203/archive/2013/05/05/3061258.html
