Java併發編程線程技術之死鎖問題如何解決

我們知道，使用 synchronized 關鍵字可以有效的解決線程同步問題，但是如果不恰當的使用 synchronized 關鍵字的話也會出問題，即我們所說的死鎖。死鎖是這樣一種情形：多個線程同時被阻塞，它們中的一個或者全部都在等待某個資源被釋放。由於線程被無限期地阻塞，因此程序不可能正常終止。

下面寫一個死鎖的例子加深理解。先看程序，再來分析一下死鎖產生的原因：

public class DeadLock {
	public static void main(String[] args) {
		Business business = new Business1();
		//開啟一個線程執行Business類中的functionA方法
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				while(true) {
					business.functionA();
				}
			}
		}).start();
		
		//開啟另一個線程執行Business類中的functionB方法
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				while(true) {
					business.functionB();
				}
			}
		}).start();
	}
}
class Business { //定義兩個鎖，兩個方法
	//定義兩個鎖
	public static final Object lock_a = new Object();
	public static final Object lock_b = new Object();	
	
	public void functionA() {
		synchronized(lock_a) {
			System.out.println("---ThreadA---lock_a---");
			synchronized(lock_b) {
				System.out.println("---ThreadA---lock_b---");
			}
		}
	}
	 

	public void functionB() {
		synchronized(lock_b) {
			System.out.println("---ThreadB---lock_b---");
			synchronized(lock_a) {
				System.out.println("---ThreadB---lock_a---");
			}
		}
	}
}

程序結構很清晰，沒什麼難度，先看一下程序的執行結果：

---ThreadA---lock_a--- ---ThreadA---lock_b--- ---ThreadA---lock_a--- ---ThreadA---lock_b--- ---ThreadA---lock_a--- ---ThreadA---lock_b--- ---ThreadA---lock_a--- ---ThreadB---lock_b---

從執行結果來看，線程A跑著跑著，當線程B一跑，啪嘰一下就掛了~我們來分析一下原因：從上面的代碼中可以看出，定義了一個類Business，該類中維護了兩個鎖和兩個方法，每個方法都是 synchronized 連環套，並且使用的是不同的鎖。好了，現在 main 方法中開啟兩個線程A和B，分別執行Business類中的兩個方法。A優先執行，跑的很爽，當B線程也開始執行的時候，問題來了，從執行結果的最後兩行來看，A線程進入了 functionA 方法中的第一個 synchronized，拿到了 lock_a 鎖，B線程進入了 functionB 中的第一個 `synchronized，拿到了 lock_b 鎖，並且兩者的鎖都還沒釋放。

接下來就是關鍵了：A線程進入第二個 synchronized 的時候，發現 lock_b 正在被B佔用，那沒辦法，它只好被阻塞，等唄~同樣地，B線程進入第二個 synchronized 的時候，發現 lock_a 正在被A佔用，那沒辦法，它也只好被阻塞，等唄~好了，兩個就這樣互相等著，你不放，我也不放……死了……

上面這個程序對於理解死鎖很有幫助，因為結構很好，不過個人感覺這個死的還不過癮，因為兩個線程是實現了兩個不同的 Runnable 接口，只不過調用了同一個類的兩個方法而已，因為我把要同步的方法放到一個類中了。下面我把程序改一下，把要同步的代碼放到一個 Runnable 中，讓它一運行就掛掉……

public class DeadLock {	
	
	public static void main(String[] args) {		
		
		//開啟兩個線程，分別扔兩個自定義的Runnable進去
		new Thread(new MyRunnable(true)).start();;
		new Thread(new MyRunnable(false)).start();;
	}
}
class MyRunnable implements Runnable
{
	private boolean flag; //用於判斷，執行不同的同步代碼塊
	
	MyRunnable(boolean flag) { //構造方法
		this.flag = flag;
	}
	
	@Override
	public void run()
	{
		if(flag)
		{
			while(true){			
				synchronized(MyLock.lock_a)
				{
					System.out.println("--threadA---lock_a--");
					synchronized(MyLock.lock_b)
					{
						System.out.println("--threadA---lock_b--");
					}	
				} 

			}
		}
		else
		{
			while(true){			
				synchronized(MyLock.lock_b)
				{
					System.out.println("--threadB---lock_a--");
					synchronized(MyLock.lock_a)
					{
						System.out.println("--threadB---lock_b--");
					}	
				}
			}
		}
	}
}
class MyLock //把兩把鎖放到一個類中定義，是為了兩個線程使用的都是這兩把鎖
{
	public static final Object lock_a = new Object();
	public static final Object lock_b = new Object();	
}

這個死鎖就厲害了，一運行，啪嘰一下直接就掛掉了……看下運行結果：

--threadA---lock_a-- --threadB---lock_b--

以上是死鎖的兩個例子，都比較容易理解和記憶，主要是“設計模式”不太一樣，第一種結構更加清晰，主函數中只要運行邏輯即可，關於同步的部分全扔到 Business 中，這個便於後期維護，我隨便把 Business 扔到哪去執行都行，因為所有同步的東西都在它自己的類中，這種設計思想很好。

第二種是把 Runnable 先定義好，通過構造方法傳進來不同的 boolean 類型值決定執行 run() 方法中不同的部分，這種思路也很容易理解，這種死鎖更厲害，兩個線程直接執行相反的部分，直接掛掉，不給對方一點情面~

死鎖就分享這麼多，如有錯誤之處，歡迎指正，我們共同進步~

關注我：私信回覆“555”獲取往期Java高級架構資料、源碼、筆記、視頻Dubbo、Redis、Netty、zookeeper、Spring cloud、分佈式、高併發等架構技術往期架構視頻截圖

閱讀更多 Java小可愛 的文章

關鍵字: 技術 線程技術 線程