傳統線程同步通信技術
先看一個問題：
有兩個線程，子線程先執行10次，然後主線程執行5次，然後再切換到子線程執行10，再主線程執行5次……如此往返執行50次。
看完這個問題，很明顯要用到線程間的通信了， 先分析一下思路：首先肯定要有兩個線程，然後每個線程中肯定有個50次的循環，因為每個線程都要往返執行任務50次，主線程的任務是執行5次，子線程的任務是執行10次。線程間通信技術主要用到 wait() 方法和 notify() 方法。wait() 方法會導致當前線程等待，並釋放所持有的鎖，notify() 方法表示喚醒在此對象監視器上等待的單個線程。下面來一步步完成這道線程間通信問題。
首先不考慮主線程和子線程之間的通信，先把各個線程所要執行的任務寫好：
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 同步代碼塊，並使用了相同的鎖：類的字節碼對象。這樣可以保證線程安全。但是這種設計不太好，就像我在上一節的死鎖中寫的一樣，我們可以把線程任務放到一個類中，這種設計的模式更加結構化，而且把不同的線程任務放到同一個類中會很容易解決同步問題，因為在一個類中很容易使用同一把鎖。所以把上面的程序修改一下：
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 同步。
下面繼續完善程序，讓兩個線程之間完成題目中所描述的那樣通信：
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 文檔中也是這麽幹的。
線程間通信就總結到這吧~若有錯誤，歡迎指正，我們一起進步。
傳統線程同步通信技術