Java併發技術05：傳統線程同步通訊技術

歡迎關注個人微信公衆號：程序員私房菜（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 文檔中也是這麼幹的。

線程間通訊就總結到這吧~如有錯誤，歡迎指正，咱們一塊兒進步。

也歡迎你們關注個人微信公衆號：程序員私房菜。我會持續輸出更多文章。