歡迎關注我的微信公眾號：程式設計師私房菜（id：eson_15）
先看一個問題：
有兩個執行緒，子執行緒先執行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 文件中也是這麼幹的。
執行緒間通訊就總結到這吧~若有錯誤，歡迎指正，我們一起進步。
也歡迎大家關注我的微信公眾號：程式設計師私房菜。我會持續輸出更多文章。
