2. 程式人生 > >java 死鎖處理方案

java 死鎖處理方案

阿新 • • 發佈：2018-12-13

在我們開發中如果我們使用多執行緒併發執行並不能帶來很大的效率提升，我建議儘可能的少使用一些多執行緒，因為我們稍有不注意就可能帶來意想不到的結果。下面簡單看一下出現死鎖情況我們該怎麼處理呢？

2.查詢到我們問題程序id,使用jstack 命令進行分析。

那麼我們遇到死鎖這種情況怎麼解決呢,我個人總結一下處理方式，如有不妥之處請廣大友人提出，共同進步。

1.保證執行緒執行順序

典型的死鎖現象：比如a,b兩個執行緒，在處理任務時我們使用了巢狀，如果順序不當很容易出現死鎖現象，我們以轉賬為例：以下是關鍵程式碼：

public class NormalTransfer implements ITransfer{
    @Override
    public void transfer(Account from, Account to, int amount)
            throws InterruptedException {
        synchronized (from){
            System.out.println(Thread.currentThread().getName()+" get "+from.getName());
            Thread.sleep(100);
            synchronized (to){
                System.out.println(Thread.currentThread().getName()
                        +" get "+to.getName());
                from.flyMoney(amount);
                to.addMoney(amount);
            }
        }
    }
}

由上述轉賬方法我們知道，在我們轉賬時需要鎖定雙方進行轉賬處理，如果我們傳入賬號順序不同那麼很容易產生死鎖，在此時我們儘可能的保證執行緒的執行順序，一個解決方案是我們可以使用一種策略就是設法讓現成按我們預想結果處理，我們使用hashcode值進行業務處理邏輯的執行，我們也需要注意一個問題，如果使用hashcode,如果被別人複寫了怎麼辦，那麼我選擇了system的hashcode的一種產生方式，原始碼可以得知這種方式不能進行復寫，在一個我們呢也要考慮在我們每天銀行轉賬那麼多，很有可能hashcode值一樣，此時我們需要新增一個競爭鎖來處理這種情況，具體程式碼如下：

public class SafeTransfer implements ITransfer {

    private static Object tieLock = new Object();

    @Override
    public void transfer(Account from, Account to, int amount)
            throws InterruptedException {

        int fromHash = System.identityHashCode(from);
        int toHash = System.identityHashCode(to);

        if(fromHash<toHash){
            synchronized (from){
                System.out.println(Thread.currentThread().getName()+" get "+from.getName());
                Thread.sleep(100);
                synchronized (to){
                    System.out.println(Thread.currentThread().getName()
                            +" get "+to.getName());
                    from.flyMoney(amount);
                    to.addMoney(amount);
                    System.out.println(from);
                    System.out.println(to);
                }
            }
        }else if(toHash<fromHash){
            synchronized (to){
                System.out.println(Thread.currentThread().getName()+" get "+to.getName());
                Thread.sleep(100);
                synchronized (from){
                    System.out.println(Thread.currentThread().getName()
                            +" get "+from.getName());
                    from.flyMoney(amount);
                    to.addMoney(amount);
                    System.out.println(from);
                    System.out.println(to);
                }
            }
        }else{
            synchronized (tieLock){


                synchronized (to){
                    System.out.println(Thread.currentThread().getName()+" get "+from.getName());
                    Thread.sleep(100);
                    synchronized (from){
                        System.out.println(Thread.currentThread().getName()
                                +" get "+to.getName());
                        from.flyMoney(amount);
                        to.addMoney(amount);
                    }
                }
            }
        }
    }
}

2.我們可以使用jdk提供的訊號量進行控制

訊號量可以控制資源能被多少執行緒訪問，這裡我們指定只能被一個執行緒訪問，就做到了類似鎖住。而訊號量可以指定去獲取的超時時間，我們可以根據這個超時時間，去做一個額外處理。

對於無法成功獲取的情況，一般就是重複嘗試，或指定嘗試的次數，也可以馬上退出。

來看下如下程式碼：

Java程式碼

 收藏程式碼

  1. package lockTest;  
  2. import java.util.Date;  
  3. import java.util.concurrent.Semaphore;  
  4. import java.util.concurrent.TimeUnit;  
  5. public class UnLockTest {  
  6.     public static String obj1 = "obj1";  
  7.     public static final Semaphore a1 = new Semaphore(1);  
  8.     public static String obj2 = "obj2";  
  9.     public static final Semaphore a2 = new Semaphore(1);  
  10.     public static void main(String[] args) {  
  11.         LockAa la = new LockAa();  
  12.         new Thread(la).start();  
  13.         LockBb lb = new LockBb();  
  14.         new Thread(lb).start();  
  15.     }  
  16. }  
  17. class LockAa implements Runnable {  
  18.     public void run() {  
  19.         try {  
  20.             System.out.println(new Date().toString() + " LockA 開始執行");  
  21.             while (true) {  
  22.                 if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {  
  23.                     System.out.println(new Date().toString() + " LockA 鎖住 obj1");  
  24.                     if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {  
  25.                         System.out.println(new Date().toString() + " LockA 鎖住 obj2");  
  26.                         Thread.sleep(60 * 1000); // do something  
  27.                     }else{  
  28.                         System.out.println(new Date().toString() + "LockA 鎖 obj2 失敗");  
  29.                     }  
  30.                 }else{  
  31.                     System.out.println(new Date().toString() + "LockA 鎖 obj1 失敗");  
  32.                 }  
  33.                 UnLockTest.a1.release(); // 釋放  
  34.                 UnLockTest.a2.release();  
  35.                 Thread.sleep(1000); // 馬上進行嘗試，現實情況下do something是不確定的  
  36.             }  
  37.         } catch (Exception e) {  
  38.             e.printStackTrace();  
  39.         }  
  40.     }  
  41. }  
  42. class LockBb implements Runnable {  
  43.     public void run() {  
  44.         try {  
  45.             System.out.println(new Date().toString() + " LockB 開始執行");  
  46.             while (true) {  
  47.                 if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {  
  48.                     System.out.println(new Date().toString() + " LockB 鎖住 obj2");  
  49.                     if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {  
  50.                         System.out.println(new Date().toString() + " LockB 鎖住 obj1");  
  51.                         Thread.sleep(60 * 1000); // do something  
  52.                     }else{  
  53.                         System.out.println(new Date().toString() + "LockB 鎖 obj1 失敗");  
  54.                     }  
  55.                 }else{  
  56.                     System.out.println(new Date().toString() + "LockB 鎖 obj2 失敗");  
  57.                 }  
  58.                 UnLockTest.a1.release(); // 釋放  
  59.                 UnLockTest.a2.release();  
  60.                 Thread.sleep(10 * 1000); // 這裡只是為了演示，所以tryAcquire只用1秒，而且B要給A讓出能執行的時間，否則兩個永遠是死鎖  
  61.             }  
  62.         } catch (Exception e) {  
  63.             e.printStackTrace();  
  64.         }  
  65.     }  
  66. }  
public class UnLockTest {
	public static String obj1 = "obj1";
	public static final Semaphore a1 = new Semaphore(1);
	public static String obj2 = "obj2";
	public static final Semaphore a2 = new Semaphore(1);

	public static void main(String[] args) {
		LockAa la = new LockAa();
		new Thread(la).start();
		LockBb lb = new LockBb();
		new Thread(lb).start();
	}
}
class LockAa implements Runnable {
	public void run() {
		try {
			System.out.println(new Date().toString() + " LockA 開始執行");
			while (true) {
				if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {
					System.out.println(new Date().toString() + " LockA 鎖住 obj1");
					if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {
						System.out.println(new Date().toString() + " LockA 鎖住 obj2");
						Thread.sleep(60 * 1000); // do something
					}else{
						System.out.println(new Date().toString() + "LockA 鎖 obj2 失敗");
					}
				}else{
					System.out.println(new Date().toString() + "LockA 鎖 obj1 失敗");
				}
				UnLockTest.a1.release(); // 釋放
				UnLockTest.a2.release();
				Thread.sleep(1000); // 馬上進行嘗試，現實情況下do something是不確定的
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
class LockBb implements Runnable {
	public void run() {
		try {
			System.out.println(new Date().toString() + " LockB 開始執行");
			while (true) {
				if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) {
					System.out.println(new Date().toString() + " LockB 鎖住 obj2");
					if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) {
						System.out.println(new Date().toString() + " LockB 鎖住 obj1");
						Thread.sleep(60 * 1000); // do something
					}else{
						System.out.println(new Date().toString() + "LockB 鎖 obj1 失敗");
					}
				}else{
					System.out.println(new Date().toString() + "LockB 鎖 obj2 失敗");
				}
				UnLockTest.a1.release(); // 釋放
				UnLockTest.a2.release();
				Thread.sleep(10 * 1000); // 這裡只是為了演示，所以tryAcquire只用1秒，而且B要給A讓出能執行的時間，否則兩個永遠是死鎖
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

看列印情況：

Java程式碼

 收藏程式碼

  1. Mon Mar 31 10:57:07 CST 2014 LockA 開始執行  
  2. Mon Mar 31 10:57:07 CST 2014 LockB 開始執行  
  3. Mon Mar 31 10:57:07 CST 2014 LockB 鎖住 obj2  
  4. Mon Mar 31 10:57:07 CST 2014 LockA 鎖住 obj1  
  5. Mon Mar 31 10:57:08 CST 2014LockB 鎖 obj1 失敗  
  6. Mon Mar 31 10:57:08 CST 2014LockA 鎖 obj2 失敗  
  7. Mon Mar 31 10:57:09 CST 2014 LockA 鎖住 obj1  
  8. Mon Mar 31 10:57:09 CST 2014 LockA 鎖住 obj2  
Mon Mar 31 10:57:07 CST 2014 LockA 開始執行
Mon Mar 31 10:57:07 CST 2014 LockB 開始執行
Mon Mar 31 10:57:07 CST 2014 LockB 鎖住 obj2
Mon Mar 31 10:57:07 CST 2014 LockA 鎖住 obj1
Mon Mar 31 10:57:08 CST 2014LockB 鎖 obj1 失敗
Mon Mar 31 10:57:08 CST 2014LockA 鎖 obj2 失敗
Mon Mar 31 10:57:09 CST 2014 LockA 鎖住 obj1
Mon Mar 31 10:57:09 CST 2014 LockA 鎖住 obj2

第一次兩個執行緒獲取訊號量時都會失敗，因為失敗後B等待時間長，所以A再次嘗試時會成功。

實際中，你執行任務內容不同，所需時間是不同的。另外不同的執行緒，對於獲取訊號量失敗的處理也可能是不同的。所以，雖然不會產生死鎖，但是你要根據實際情況，來編寫獲取失敗後的處理機制。

3.我們可以使用重入鎖進行處理，在我們賬戶物件中設定重入鎖屬性，在我們執行緒執行時首先我們獲取我們重入鎖，然後才能進行執行任務。

public class TryLockTransfer implements ITransfer {
    @Override
    public void transfer(Account from, Account to, int amount)
            throws InterruptedException {
        Random r = new Random();
        while(true){
            if(from.getLock().tryLock()){
                try{
                    System.out.println(Thread.currentThread().getName()
                            +" get from "+from.getName());

                    if(to.getLock().tryLock()){
                        try{
                            System.out.println(Thread.currentThread().getName()
                                    +" get to "+to.getName());
                            from.flyMoney(amount);
                            to.addMoney(amount);
                            System.out.println(from);
                            System.out.println(to);
                            break;
                        }finally {
                            to.getLock().unlock();
                        }
                    }

                }finally {
                   from.getLock().unlock();
                }
            }
            Thread.sleep(r.nextInt(5));//防止產生活鎖
        }
    }
}

注意：上述產生活鎖產生解決是增加休眠時間，活鎖個人理解就是我們多執行緒爭奪瑣時，比如a執行緒想要獲取鎖，但是又考慮到別人也需要，所以此時它退出競爭，但是又一直試圖去獲取，這樣就形成了活鎖。

相關推薦

java 死鎖處理方案

在我們開發中如果我們使用多執行緒併發執行並不能帶來很大的效率提升，我建議儘可能的少使用一些多執行緒，因為我們稍有不注意就可能帶來意想不到的結果。下面簡單看一下出現死鎖情況我們該怎麼處理呢？ 2.查詢到我們問題程序id,使用jstack 命令進行分析。 那麼我們遇到死鎖

（十六）java併發程式設計--執行緒的死鎖解決方案(生產者和消費者幾種實現方式)

上一篇中,主要了解了什麼時候死鎖，並且提出死鎖的一個解決方案，多個鎖要按照一定的順序來。 本片主要是利用生產者消費者模式解決執行緒的死鎖。 多執行緒生產者和消費者一個典型的多執行緒程式。一個生產者生產提供消費的東西，但是生產速度和消費速度是不同的。這就需要讓

Java死鎖

允許 class err pub 完全 tac san 執行 rup 代碼如下： 1 package com.synchronizeddemo01; 2 3 class Zhangsan{ 4 public void say(){ 5

Java死鎖舉例

nbsp 產生 cep -a pack 存在 bsp trac code 死鎖： 在多線程競爭使用共享資源的情況下。就有可能出現死鎖的情況。比方，當一個線程等待還有一個線程所持有的鎖時。那個線程又可能在等待第一個線程所持有的鎖。此時。這兩個線程會陷入無休止

java死鎖問題

我們 告訴 tac image http 了解 src bsp 分享 一.先從定義上了解一下死鎖 二.從代碼角度上去解釋一下死鎖問題 三.上述程序就是出現了死鎖，我們來查看一下 1.命令如下 cmd>>jps(查看到了死鎖線程所在的類，前面是

Java 死鎖

ron func run blog pub read 同步 lock println /* 死鎖：常見情景之一：同步的嵌套。 */ class Test implements Runnable { private boolean flag;

死鎖處理

inpu gin 記錄 where spi select lin create begin if exists (select * from dbo.sysobjects where id = object_id(N‘[dbo].[sp_who_lock]‘) and OB

Java死鎖範例以及如何分析死鎖（轉載自ImportNew）

ofo index 對象 str wait 就會 moni ask 進入 本文由 ImportNew - 範琦琦 翻譯自 journaldev。歡迎加入翻譯小組。轉載請見文末要求。 死鎖是兩個甚至多個線程被永久阻塞時的一種運行局面，這種局面的生成伴隨著至少兩個線程和兩個或者

Java死鎖以及命令檢測

阻塞 one found font pat rgs strong thread ron Java每個對象都有一把鎖，當前進程使用對象鎖1，沒有釋放該鎖，又想要去獲取另一把對象鎖2，而對象鎖2被另外一個線程持有，沒有釋放，這就很容易出現死鎖 1.死鎖實例 public cl

死鎖處理【轉】

若是 狀態 net from transfer csdn tails 最好 出現 轉自：lemonGuo 死鎖出現的場景 根據以上分析總結一下最壞的情況： synchronized(from)：別的線程在等待from對象； synchronized(to)：別的

作業系統（10）程序--死鎖概念；死鎖處理方法：死鎖預防、死鎖避免、銀行家演算法、死鎖檢測

文章目錄 1. 死鎖概念 2. 死鎖處理方法 1. 死鎖預防 2. 死鎖避免 3. 銀行家演算法 4. 死鎖檢測 1. 死鎖概念 死鎖是指：由於競爭資源或者通

sql server 表死鎖處理辦法

-- 查詢死鎖 select request_session_id spid, OBJECT_NAME(resource_associated_entity_id) tableName from sys.dm_tran_locks

一個JAVA死鎖的Demo

死鎖的條件肯定是兩個鎖以上時，才會 發生死鎖，以下Demo是模擬的兩個鎖，通過兩個執行緒分別呼叫兩個方法，這兩個方法加鎖的順序正好相反，從而造成兩個執行緒相互等待，互不釋放鎖 package com.threadDemo; public class DeadlockSam

mysql 死鎖處理 查詢等操作無響應

mysql  死鎖處理     MySQL如果頻繁的修改一個表的資料，那麼這麼表會被鎖死。造成假死現象。 比如用Navicat等連線工具操作，Navicat會直接未響應，只能強制關閉軟體，但是重啟後依然無效。   解決辦法： &nb

sql server死鎖解決方案

問題場景：在客戶那碰到一個操作卡死的現象 問題解決： 1、如何掛鉤是死鎖問題：通過程式碼跟蹤，發現是指執行一個SQL語句超時，因此猜想可能是表鎖住了 2、如果確認是思索問題：通過SQL發現死鎖，以下是相關的SQL  select request_session_id 

Java死鎖程式碼示例

public class DeadLocak { private final Object left = new Object(); private final Object right = new Object(); public void le

java同步鎖優化方案學習筆記（偏向鎖，輕量級鎖，自旋鎖，重量級鎖）

目錄 一，概述 二，CAS 一，概述 什麼是java的鎖？ 為什麼java要有鎖？ java的鎖為什麼需要優化？ 怎麼優化的？ 1，java中使用synchronized關鍵字來實現同步功能，被synchronized修飾的方法

java-死鎖現象及解決方法

摘自：http://blog.csdn.net/joejames/article/details/37960873 所謂死鎖：是指兩個或兩個以上的程序在執行過程中，因爭奪資源而造成的一種互相等待的現象，若無外力作用，它們都將無法推進下去。此時稱系統處於死鎖狀

Java 死鎖例子（註釋詳細）

為了測試java多執行緒死鎖 得到java多執行緒死鎖的直觀感覺，寫出以下測試程式碼。 public class DeadLock { public static String obj1 = "obj1"; public static String obj2 = "obj2";

java死鎖產生的原因

產生死鎖，至少有兩把鎖，多執行緒。一般是A執行緒獲取A鎖，B執行緒獲取了B鎖，這時A執行緒又要獲取B鎖，B執行緒又要獲取A鎖，從而導致死鎖，這個會出現程式碼不繼續執行了，可以用jconsole分析，哪個執行緒產生了死鎖。 1、程式至少有兩把鎖，相互鎖住。 public c