java多線程學(xué)習(xí)之死鎖的模擬和避免(實例講解)

更新時間：2017年06月26日 09:08:09 投稿：jingxian

下面小編就為大家?guī)硪黄猨ava多線程學(xué)習(xí)之死鎖的模擬和避免(實例講解)。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧

1.死鎖

死鎖是這樣一種情形：多個線程同時被阻塞，它們中的一個或者全部都在等待某個資源被釋放。由于線程被無限期地阻塞，因此程序不可能正常終止。

Java 死鎖產(chǎn)生的四個必要條件：

1、互斥使用，即當(dāng)資源被一個線程使用(占有)時，別的線程不能使用

2、不可搶占，資源請求者不能強制從資源占有者手中奪取資源，資源只能由資源占有者主動釋放。

3、請求和保持，即當(dāng)資源請求者在請求其他的資源的同時保持對原有資源的占有。

4、循環(huán)等待，即存在一個等待隊列：P1占有P2的資源，P2占有P3的資源，P3占有P1的資源。這樣就形成了一個等待環(huán)路。

當(dāng)上述四個條件都成立的時候，便形成死鎖。當(dāng)然，死鎖的情況下如果打破上述任何一個條件，便可讓死鎖消失。

2.模擬一個死鎖

package com.tl.skyLine.thread; 
 
import java.util.Date; 
 
/** 
 * Created by tl on 17/3/3. 
 */ 
public class DeadLock { 
 public static String bowl = "碗"; 
 public static String chopsticks = "筷子"; 
 
 public static void main(String[] args) { 
  LockA la = new LockA(); 
  new Thread(la).start(); 
  LockB lb = new LockB(); 
  new Thread(lb).start(); 
 } 
 
} 
 
 
class LockA implements Runnable { 
 public void run() { 
  try { 
   System.out.println(new Date().toString() + "鄒保健開始拿餐具吃飯"); 
   while (true) { 
    synchronized (DeadLock.bowl) { 
     System.out.println(new Date().toString() + "鄒保健搶到了碗"); 
     Thread.sleep(3000); // 此處等待是給B能鎖住機(jī)會 
     synchronized (DeadLock.chopsticks) { 
      System.out.println(new Date().toString() + "鄒保健搶到了筷子"); 
      Thread.sleep(60 * 1000); // 為測試，占用了就不放 
     } 
    } 
   } 
  } catch (Exception e) { 
   e.printStackTrace(); 
  } 
 } 
} 
 
class LockB implements Runnable { 
 public void run() { 
  try { 
   System.out.println(new Date().toString() + "陳頂天開始拿餐具吃飯"); 
   while (true) { 
    synchronized (DeadLock.chopsticks) { 
     System.out.println(new Date().toString() + "陳頂天搶到了筷子"); 
     Thread.sleep(3000); // 此處等待是給A能鎖住機(jī)會 
     synchronized (DeadLock.bowl) { 
      System.out.println(new Date().toString() + "陳頂天搶到了碗"); 
      Thread.sleep(60 * 1000); // 為測試，占用了就不放 
     } 
    } 
   } 
  } catch (Exception e) { 
   e.printStackTrace(); 
  } 
 } 
}

結(jié)果：

Fri Mar 03 16:34:36 CST 2017陳頂天開始拿餐具吃飯 
Fri Mar 03 16:34:37 CST 2017陳頂天搶到了筷子 
Fri Mar 03 16:34:36 CST 2017鄒保健開始拿餐具吃飯 
Fri Mar 03 16:34:37 CST 2017鄒保健搶到了碗

結(jié)果陳頂天同學(xué)搶到了參筷子，拿著不放，鄒保健同學(xué)搶到了碗，也死活不放手，但是只有一雙筷子和一雙碗，結(jié)果就是雙雙餓死。。。

3.避免死鎖

假如我們是陳頂天和鄒保健同學(xué)的同事，肯定不忍心看到他們餓死，那么怎么辦呢？

我們就要采取方法避免思索的發(fā)生，這邊介紹兩種方法，一種是加鎖順序（線程按照一定的順序加鎖）；另一種是加鎖時限（線程嘗試獲取鎖的時候加上一定的時限，超過時限則放棄對該鎖的請求，并釋放自己占有的鎖）；

3.1 加鎖順序

當(dāng)多個線程需要相同的一些鎖，但是按照不同的順序加鎖，死鎖就很容易發(fā)生。如果能確保所有的線程都是按照相同的順序獲得鎖，那么死鎖就不會發(fā)生。我們上面的代碼為了模擬死鎖，將線程LockA與LockB兩位同事的搶奪資源順序做了一個調(diào)整，LockA先搶碗，然后sleep3秒，LockB先搶筷子，我們現(xiàn)在把爭奪資源順序改一下，兩個線程都是先搶碗，再搶筷子，嚴(yán)格按照這個順序運行，那么A搶到碗以后，B去爭奪資源，必須從搶碗開始，不能在搶不到碗的情況下去搶筷子，這樣就避免死鎖的發(fā)生，這也是避免死鎖最簡單的方法。

代碼修改如下：

/** 
 * Created by tl on 17/3/3. 
 */ 
public class UnDeadLock { 
 public static String bowl = "碗"; 
 public static String chopsticks = "筷子"; 
 
 public static void main(String[] args) { 
  LockA la = new LockA(); 
  new Thread(la).start(); 
  LockB lb = new LockB(); 
  new Thread(lb).start(); 
 } 
 
} 
 
 
class LockA implements Runnable { 
 public void run() { 
  try { 
   System.out.println(new Date().toString() + "鄒保健開始拿餐具吃飯"); 
   while (true) { 
    synchronized (UnDeadLock.bowl) { 
     System.out.println(new Date().toString() + "鄒保健搶到了碗"); 
     synchronized (UnDeadLock.chopsticks) { 
      System.out.println(new Date().toString() + "鄒保健搶到了筷子"); 
     } 
    } 
    Thread.sleep(5000); 
   } 
  } catch (Exception e) { 
   e.printStackTrace(); 
  } 
 } 
} 
 
class LockB implements Runnable { 
 public void run() { 
  try { 
   System.out.println(new Date().toString() + "陳頂天開始拿餐具吃飯"); 
   while (true) { 
    synchronized (UnDeadLock.bowl) { 
     System.out.println(new Date().toString() + "陳頂天搶到了碗"); 
     synchronized (UnDeadLock.chopsticks) { 
      System.out.println(new Date().toString() + "陳頂天搶到了筷子"); 
     } 
    } 
    Thread.sleep(5000); 
   } 
  } catch (Exception e) { 
   e.printStackTrace(); 
  } 
 } 
}

此時運行結(jié)果

Fri Mar 24 11:16:51 CST 2017鄒保健開始拿餐具吃飯 
Fri Mar 24 11:16:51 CST 2017陳頂天開始拿餐具吃飯 
Fri Mar 24 11:16:51 CST 2017鄒保健搶到了碗 
Fri Mar 24 11:16:51 CST 2017鄒保健搶到了筷子 
Fri Mar 24 11:16:51 CST 2017陳頂天搶到了碗 
Fri Mar 24 11:16:51 CST 2017陳頂天搶到了筷子 
Fri Mar 24 11:16:56 CST 2017鄒保健搶到了碗 
Fri Mar 24 11:16:56 CST 2017鄒保健搶到了筷子 
Fri Mar 24 11:16:56 CST 2017陳頂天搶到了碗 
Fri Mar 24 11:16:56 CST 2017陳頂天搶到了筷子 
Fri Mar 24 11:17:01 CST 2017鄒保健搶到了碗 
Fri Mar 24 11:17:01 CST 2017鄒保健搶到了筷子

就不會再出現(xiàn)死鎖的情況了。

3.2 加鎖時效

加鎖時效的原理就是：給每一個訪問線程增加訪問時效，若一個線程沒有在給定的時限內(nèi)成功獲得所有需要的鎖，則會進(jìn)行回退并釋放所有已經(jīng)獲得的鎖（此時就打破了造成死鎖的四個原因中的第三個原因），然后等待一段隨機(jī)的時間再重試。

為了實現(xiàn)這個目標(biāo)，我們不使用顯示的去鎖，我而是用信號量Semaphore去控制。信號量可以控制資源能被多少線程訪問，這里我們指定只能被一個線程訪問，就做到了類似鎖住。而信號量可以指定去獲取的超時時間，我們可以根據(jù)這個超時時間，去做一個額外處理。對于無法成功獲取的情況，一般就是重復(fù)嘗試，或指定嘗試的次數(shù)，也可以馬上退出。

package com.tl.skyLine.thread; 
 
import java.util.Date; 
import java.util.concurrent.Semaphore; 
import java.util.concurrent.TimeUnit; 
 
/** 
 * Created by tl on 17/3/3. 
 */ 
public class UnDeadLock { 
 public static String bowl = "碗"; 
 //信號量可以碗只能能被一個線程同時訪問 
 public static final Semaphore a1 = new Semaphore(1); 
 public static String chopsticks = "筷子"; 
 //信號量可以筷子只能能被一個線程同時訪問 
 public static final Semaphore a2 = new Semaphore(1); 
 
 public static void main(String[] args) { 
  LockAa la = new LockAa(); 
  new Thread(la).start(); 
  LockBa lb = new LockBa(); 
  new Thread(lb).start(); 
 } 
 
} 
 
 
class LockAa implements Runnable { 
 public void run() { 
  try { 
   System.out.println(new Date().toString() + "鄒保健開始拿餐具吃飯"); 
   while (true) { 
    if (UnDeadLock.a1.tryAcquire(1, TimeUnit.SECONDS)) { 
     System.out.println(new Date().toString() + "鄒保健搶到了碗"); 
     if (UnDeadLock.a2.tryAcquire(1, TimeUnit.SECONDS)) { 
      System.out.println(new Date().toString() + "鄒保健搶到了筷子,湊齊了餐具,準(zhǔn)備吃飯"); 
      Thread.sleep(60 * 1000 * 10); // 搶到餐具就開始吃飯,吃飯時間十分鐘 
     } else { 
      System.out.println(new Date().toString() + "筷子已經(jīng)被搶走了,鄒保健搶筷子失敗"); 
     } 
    } else { 
     System.out.println(new Date().toString() + "碗已經(jīng)被搶走了,鄒保健搶碗失敗"); 
    } 
 
    UnDeadLock.a1.release(); // 釋放 
    UnDeadLock.a2.release(); 
    System.out.println(new Date().toString() + "鄒保健把搶到的部分餐具又放回原處"); 
    Thread.sleep(1000); // 馬上進(jìn)行嘗試，現(xiàn)實情況下do something是不確定的 
   } 
  } catch (Exception e) { 
   e.printStackTrace(); 
  } 
 } 
} 
 
 
class LockBa implements Runnable { 
 public void run() { 
  try { 
   System.out.println(new Date().toString() + "陳頂天開始拿餐具吃飯"); 
   while (true) { 
    if (UnDeadLock.a2.tryAcquire(1, TimeUnit.SECONDS)) { 
     System.out.println(new Date().toString() + "陳頂天搶到了筷子"); 
     if (UnDeadLock.a1.tryAcquire(1, TimeUnit.SECONDS)) { 
      System.out.println(new Date().toString() + "陳頂天搶到了碗,湊齊了餐具,準(zhǔn)備吃飯"); 
      Thread.sleep(60 * 1000 * 10); // 搶到餐具就開始吃飯,吃飯時間十分鐘 
     } else { 
      System.out.println(new Date().toString() + "碗已經(jīng)被搶走了,陳頂天搶碗失敗"); 
     } 
    } else { 
     System.out.println(new Date().toString() + "筷子已經(jīng)被搶走了,陳頂天搶筷子失敗"); 
    } 
 
    UnDeadLock.a1.release(); // 釋放 
    UnDeadLock.a2.release(); 
    System.out.println(new Date().toString() + "陳頂天把搶到的部分餐具又放回原處"); 
    Thread.sleep(10 * 1000);//這里只是為了演示，所以tryAcquire只用1秒，而且B要給A讓出能執(zhí)行的時間，否則兩個永遠(yuǎn)是死鎖 
   } 
  } catch (Exception e) { 
   e.printStackTrace(); 
  } 
 } 
}

結(jié)果

Fri Mar 03 18:12:07 CST 2017鄒保健開始拿餐具吃飯 
Fri Mar 03 18:12:07 CST 2017陳頂天開始拿餐具吃飯 
Fri Mar 03 18:12:07 CST 2017鄒保健搶到了碗 
Fri Mar 03 18:12:07 CST 2017陳頂天搶到了筷子 
Fri Mar 03 18:12:08 CST 2017筷子已經(jīng)被搶走了,鄒保健搶筷子失敗 
Fri Mar 03 18:12:08 CST 2017鄒保健把搶到的部分餐具又放回原處 
Fri Mar 03 18:12:08 CST 2017陳頂天搶到了碗,湊齊了餐具,準(zhǔn)備吃飯 
Fri Mar 03 18:12:10 CST 2017碗已經(jīng)被搶走了,鄒保健搶碗失敗 
Fri Mar 03 18:12:10 CST 2017鄒保健把搶到的部分餐具又放回原處 
Fri Mar 03 18:12:11 CST 2017鄒保健搶到了碗 
Fri Mar 03 18:12:11 CST 2017鄒保健搶到了筷子,湊齊了餐具,準(zhǔn)備吃飯

很明顯看到，我們打破了滿足死鎖的第三條，即當(dāng)資源請求者在請求其他的資源的同時保持對原有資源的占有，當(dāng)沒有完全搶到碗和筷子的時候，兩個人（線程）全部釋放占有的資源，重新開始爭搶資源，這樣一個人搶到碗和筷子之后，吃飽再給另一個吃，這樣你就成功了拯救了你的兩位同事！

Semaphore api：

acquire 
 
public void acquire() 
    throws InterruptedException 
 
 從此信號量獲取一個許可，在提供一個許可前一直將線程阻塞，否則線程被中斷。獲取一個許可（如果提供了一個）并立即返回，將可用的許可數(shù)減 1。 
 
 如果沒有可用的許可，則在發(fā)生以下兩種情況之一前，禁止將當(dāng)前線程用于線程安排目的并使其處于休眠狀態(tài)： 
 
  某些其他線程調(diào)用此信號量的 release() 方法，并且當(dāng)前線程是下一個要被分配許可的線程；或者 
  其他某些線程中斷當(dāng)前線程。 
 
 如果當(dāng)前線程： 
 
  被此方法將其已中斷狀態(tài)設(shè)置為 on ；或者 
  在等待許可時被中斷。 
 
 則拋出 InterruptedException，并且清除當(dāng)前線程的已中斷狀態(tài)。 
 
 拋出： 
  InterruptedException - 如果當(dāng)前線程被中斷 
 
release 
 
public void release() 
 
 釋放一個許可，將其返回給信號量。釋放一個許可，將可用的許可數(shù)增加 1。如果任意線程試圖獲取許可，則選中一個線程并將剛剛釋放的許可給予它。然后針對線程安排目的啟用（或再啟用）該線程。 
 
 不要求釋放許可的線程必須通過調(diào)用 acquire() 來獲取許可。通過應(yīng)用程序中的編程約定來建立信號量的正確用法。

wait()與sleep()的區(qū)別：

sleep()方法只讓出了CPU，而并不會釋放同步資源鎖?。?！

wait()方法則是指當(dāng)前線程讓自己暫時退讓出同步資源鎖，以便其他正在等待該資源的線程得到該資源進(jìn)而運行;

以上這篇java多線程學(xué)習(xí)之死鎖的模擬和避免(實例講解)就是小編分享給大家的全部內(nèi)容了，希望能給大家一個參考，也希望大家多多支持腳本之家。

您可能感興趣的文章: