Java并發(fā)之傳統(tǒng)線程同步通信技術(shù)代碼詳解

更新時間：2018年02月06日 09:13:47 作者：eson_15

這篇文章主要介紹了Java并發(fā)之傳統(tǒng)線程同步通信技術(shù)代碼詳解，分享了相關(guān)代碼示例，小編覺得還是挺不錯的，具有一定借鑒價值，需要的朋友可以參考下

本文研究的主要是Java并發(fā)之傳統(tǒng)線程同步通信技術(shù)的相關(guān)代碼示例，具體介紹如下。

先看一個問題：

有兩個線程，子線程先執(zhí)行10次，然后主線程執(zhí)行5次，然后再切換到子線程執(zhí)行10，再主線程執(zhí)行5次……如此往返執(zhí)行50次。

看完這個問題，很明顯要用到線程間的通信了，先分析一下思路：首先肯定要有兩個線程，然后每個線程中肯定有個50次的循環(huán)，因為每個線程都要往返執(zhí)行任務(wù)50次，主線程的任務(wù)是執(zhí)行5次，子線程的任務(wù)是執(zhí)行10次。線程間通信技術(shù)主要用到wait()方法和notify()方法。wait()方法會導致當前線程等待，并釋放所持有的鎖，notify()方法表示喚醒在此對象監(jiān)視器上等待的單個線程。下面來一步步完成這道線程間通信問題。

首先不考慮主線程和子線程之間的通信，先把各個線程所要執(zhí)行的任務(wù)寫好：

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) {
						//子線程任務(wù)：執(zhí)行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) {
				//主線程任務(wù)：執(zhí)行5次
				for (int j = 1;j <= 5; j ++) {
					System.out.println("main thread sequence of " + j + ", loop of " + i);
				}
			}
		}
	}
}

如上，兩個線程各有50次大循環(huán)，執(zhí)行50次任務(wù)，子線程的任務(wù)是執(zhí)行10次，主線程的任務(wù)是執(zhí)行5次。為了保證兩個線程間的同步問題，所以用了synchronized同步代碼塊，并使用了相同的鎖：類的字節(jié)碼對象。這樣可以保證線程安全。但是這種設(shè)計不太好，就像我在上一節(jié)的死鎖中寫的一樣，我們可以把線程任務(wù)放到一個類中，這種設(shè)計的模式更加結(jié)構(gòu)化，而且把不同的線程任務(wù)放到同一個類中會很容易解決同步問題，因為在一個類中很容易使用同一把鎖。所以把上面的程序修改一下：

public class TraditionalThreadCommunication {
	public static void main(String[] args) {
		Business bussiness = new Business();
		//new一個線程任務(wù)處理類
		//開啟一個子線程
		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);
		}
	}
}
//要用到的共同數(shù)據(jù)（包括同步鎖）或共同的若干個方法應(yīng)該歸在同一個類身上，這種設(shè)計正好體現(xiàn)了高類聚和程序的健壯性。
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);
		}
	}

經(jīng)過這樣修改后，程序結(jié)構(gòu)更加清晰了，也更加健壯了，只要在兩個線程任務(wù)方法上加上synchronized關(guān)鍵字即可，用的都是this這把鎖。但是現(xiàn)在兩個線程之間還沒有通信，執(zhí)行的結(jié)果是主線程循環(huán)執(zhí)行任務(wù)50次，然后子線程再循環(huán)執(zhí)行任務(wù)50次，原因很簡單，因為有synchronized同步。

下面繼續(xù)完善程序，讓兩個線程之間完成題目中所描述的那樣通信：

public class TraditionalThreadCommunication {
	public static void main(String[] args) {
		Business bussiness = new Business();
		//new一個線程任務(wù)處理類
		//開啟一個子線程
		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);
		}
	}
}
//要用到共同數(shù)據(jù)（包括同步鎖）或共同的若干個方法應(yīng)該歸在同一個類身上，這種設(shè)計正好體現(xiàn)了高雷劇和程序的健壯性。
class Business {
	private Boolean bShouldSub = true;
	public synchronized void sub(int i) {
		while(!bShouldSub) {
			//如果不輪到自己執(zhí)行，就睡
			try {
				this.wait();
				//調(diào)用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) {
			//如果不輪到自己執(zhí)行，就睡
			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();
		//喚醒正在等待的子線程
	}
}

首先，先不說具體的程序?qū)崿F(xiàn)，就從結(jié)構(gòu)上來看，已經(jīng)體會到了這種設(shè)計的好處了：主函數(shù)里不用修改任何東西，關(guān)于線程間同步和線程間通信的邏輯全都在Business類中，主函數(shù)中的不同線程只需要調(diào)用放在該類中對應(yīng)的任務(wù)即可。體現(xiàn)了高類聚的好處。

再看一下具體的代碼，首先定義一個boolean型變量來標識哪個線程該執(zhí)行，當不是子線程執(zhí)行的時候，它就睡，那么很自然主線程就執(zhí)行了，執(zhí)行完了，修改了bShouldSub并喚醒了子線程，子線程這時候再判斷一下while不滿足了，就不睡了，就執(zhí)行子線程任務(wù)，同樣地，剛剛主線程修改了bShouldSub后，第二次循環(huán)來執(zhí)行主線程任務(wù)的時候，判斷while滿足就睡了，等待子線程來喚醒。這樣邏輯就很清楚了，主線程和子線程你一下我一下輪流執(zhí)行各自的任務(wù)，這種節(jié)奏共循環(huán)50次。

另外有個小小的說明：這里其實用if來判斷也是可以的，但是為什么要用while呢?因為有時候線程會假醒(就好像人的夢游，明明正在睡，結(jié)果站起來了)，如果用的是if的話，那么它假醒了后，就不會再返回去判斷if了，那它就很自然的往下執(zhí)行任務(wù)，好了，另一個線程正在執(zhí)行呢，啪嘰一下就與另一個線程之間相互影響了。但是如果是while的話就不一樣了，就算線程假醒了，它還會判斷一下while的，但是此時另一個線程在執(zhí)行啊，bShouldSub并沒有被修改，所以還是進到while里了，又被睡了~所以很安全，不會影響另一個線程!官方JDK文檔中也是這么干的。

線程間通信就總結(jié)到這吧~