本文研究的主要是Java并發之傳統線程同步通信技術的相關代碼示例，具體介紹如下。
先看一個問題：
有兩個線程，子線程先執行10次，然后主線程執行5次，然后再切換到子線程執行10，再主線程執行5次……如此往返執行50次。
看完這個問題，很明顯要用到線程間的通信了， 先分析一下思路：首先肯定要有兩個線程，然后每個線程中肯定有個50次的循環，因為每個線程都要往返執行任務50次，主線程的任務是執行5次，子線程的任務是執行10次。線程間通信技術主要用到wait()方法和notify()方法。wait()方法會導致當前線程等待，并釋放所持有的鎖，notify()方法表示喚醒在此對象監視器上等待的單個線程。下面來一步步完成這道線程間通信問題。
首先不考慮主線程和子線程之間的通信，先把各個線程所要執行的任務寫好：
|
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
|
public class TraditionalThreadCommunication { public static void main(String[] args) { //開啟一個子線程 new Thread(new Runnable() { @Override public void run() { for (int i = 1; i <= 50; i ++) { synchronized (TraditionalThreadCommunication.class) { //子線程任務：執行10次 for (int j = 1;j <= 10; j ++) { System.out.println("sub thread sequence of " + j + ", loop of " + i); } } } } } ).start(); //main方法即主線程 for (int i = 1; i <= 50; i ++) { synchronized (TraditionalThreadCommunication.class) { //主線程任務：執行5次 for (int j = 1;j <= 5; j ++) { System.out.println("main thread sequence of " + j + ", loop of " + i); } } } }} |
如上，兩個線程各有50次大循環，執行50次任務，子線程的任務是執行10次，主線程的任務是執行5次。為了保證兩個線程間的同步問題，所以用了synchronized同步代碼塊，并使用了相同的鎖：類的字節碼對象。這樣可以保證線程安全。但是這種設計不太好，就像我在上一節的死鎖中寫的一樣，我們可以把線程任務放到一個類中，這種設計的模式更加結構化，而且把不同的線程任務放到同一個類中會很容易解決同步問題，因為在一個類中很容易使用同一把鎖。所以把上面的程序修改一下：
|
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
|
public class TraditionalThreadCommunication { public static void main(String[] args) { Business bussiness = new Business(); //new一個線程任務處理類 //開啟一個子線程 new Thread(new Runnable() { @Override public void run() { for (int i = 1; i <= 50; i ++) { bussiness.sub(i); } } } ).start(); //main方法即主線程 for (int i = 1; i <= 50; i ++) { bussiness.main(i); } }}//要用到的共同數據（包括同步鎖）或共同的若干個方法應該歸在同一個類身上，這種設計正好體現了高類聚和程序的健壯性。class Business { public synchronized void sub(int i) { for (int j = 1;j <= 10; j ++) { System.out.println("sub thread sequence of " + j + ", loop of " + i); } } public synchronized void main(int i) { for (int j = 1;j <= 5; j ++) { System.out.println("main thread sequence of " + j + ", loop of " + i); } } |
經過這樣修改后，程序結構更加清晰了，也更加健壯了，只要在兩個線程任務方法上加上synchronized關鍵字即可，用的都是this這把鎖。但是現在兩個線程之間還沒有通信，執行的結果是主線程循環執行任務50次，然后子線程再循環執行任務50次，原因很簡單，因為有synchronized同步。
下面繼續完善程序，讓兩個線程之間完成題目中所描述的那樣通信：
|
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
|
public class TraditionalThreadCommunication { public static void main(String[] args) { Business bussiness = new Business(); //new一個線程任務處理類 //開啟一個子線程 new Thread(new Runnable() { @Override public void run() { for (int i = 1; i <= 50; i ++) { bussiness.sub(i); } } } ).start(); //main方法即主線程 for (int i = 1; i <= 50; i ++) { bussiness.main(i); } }}//要用到共同數據（包括同步鎖）或共同的若干個方法應該歸在同一個類身上，這種設計正好體現了高雷劇和程序的健壯性。class Business { private Boolean bShouldSub = true; public synchronized void sub(int i) { while(!bShouldSub) { //如果不輪到自己執行，就睡 try { this.wait(); //調用wait()方法的對象必須和synchronized鎖對象一致，這里synchronized在方法上，所以用this } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } for (int j = 1;j <= 10; j ++) { System.out.println("sub thread sequence of " + j + ", loop of " + i); } bShouldSub = false; //改變標記 this.notify(); //喚醒正在等待的主線程 } public synchronized void main(int i) { while(bShouldSub) { //如果不輪到自己執行，就睡 try { this.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } for (int j = 1;j <= 5; j ++) { System.out.println("main thread sequence of " + j + ", loop of " + i); } bShouldSub = true; //改變標記 this.notify(); //喚醒正在等待的子線程 }} |
首先，先不說具體的程序實現，就從結構上來看，已經體會到了這種設計的好處了：主函數里不用修改任何東西，關于線程間同步和線程間通信的邏輯全都在Business類中，主函數中的不同線程只需要調用放在該類中對應的任務即可。體現了高類聚的好處。
再看一下具體的代碼，首先定義一個boolean型變量來標識哪個線程該執行，當不是子線程執行的時候，它就睡，那么很自然主線程就執行了，執行完了，修改了bShouldSub并喚醒了子線程，子線程這時候再判斷一下while不滿足了，就不睡了，就執行子線程任務，同樣地，剛剛主線程修改了bShouldSub后，第二次循環來執行主線程任務的時候，判斷while滿足就睡了，等待子線程來喚醒。這樣邏輯就很清楚了，主線程和子線程你一下我一下輪流執行各自的任務，這種節奏共循環50次。
另外有個小小的說明：這里其實用if來判斷也是可以的，但是為什么要用while呢?因為有時候線程會假醒(就好像人的夢游，明明正在睡，結果站起來了)，如果用的是if的話，那么它假醒了后，就不會再返回去判斷if了，那它就很自然的往下執行任務，好了，另一個線程正在執行呢，啪嘰一下就與另一個線程之間相互影響了。但是如果是while的話就不一樣了，就算線程假醒了，它還會判斷一下while的，但是此時另一個線程在執行啊，bShouldSub并沒有被修改，所以還是進到while里了，又被睡了~所以很安全，不會影響另一個線程!官方JDK文檔中也是這么干的。
線程間通信就總結到這吧~
總結
以上就是本文關于Java并發之傳統線程同步通信技術代碼詳解的全部內容，希望對大家有所幫助。感興趣的朋友可以繼續參閱本站其他相關專題，如有不足之處，歡迎留言指出。感謝朋友們對本站的支持！
原文鏈接：http://blog.csdn.net/eson_15/article/details/51530778
