Java 死鎖及解決方法

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

java 死鎖產生的四個必要條件：

• 1>互斥使用，即當資源被一個線程使用(占有)時，別的線程不能使用
• 2>不可搶占，資源請求者不能強制從資源占有者手中奪取資源，資源只能由資源占有者主動釋放。
• 3>請求和保持，即當資源請求者在請求其他的資源的同時保持對原有資源的戰友。
• 4>循環等待，即存在一個等待隊列：P1占有P2的資源，P2占有P3的資源，P3占有P1的資源。這樣就形成了一個等待環路。

當上述四個條件都成立的時候，便形成死鎖。當然，死鎖的情況下如果打破上述任何一個條件，便可讓死鎖消失。下面用java代碼來模擬一下死鎖的產生。

解決死鎖問題的方法是：一種是用synchronized，一種是用Lock顯式鎖實現。

而如果不恰當的使用了鎖，且出現同時要鎖多個對象時，會出現死鎖情況，如下：

import java.util.Date;

public class LockTest {
   public static String obj1 = "obj1";
   public static String obj2 = "obj2";
   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() + " LockA 開始執行");
         while(true){
            synchronized (LockTest.obj1) {
               System.out.println(new Date().toString() + " LockA 鎖住 obj1");
               Thread.sleep(3000); // 此處等待是給B能鎖住機會
               synchronized (LockTest.obj2) {
                  System.out.println(new Date().toString() + " LockA 鎖住 obj2");
                  Thread.sleep(60 * 1000); // 為測試，占用了就不放
               }
            }
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}
class LockB implements Runnable{
   public void run() {
      try {
         System.out.println(new Date().toString() + " LockB 開始執行");
         while(true){
            synchronized (LockTest.obj2) {
               System.out.println(new Date().toString() + " LockB 鎖住 obj2");
               Thread.sleep(3000); // 此處等待是給A能鎖住機會
               synchronized (LockTest.obj1) {
                  System.out.println(new Date().toString() + " LockB 鎖住 obj1");
                  Thread.sleep(60 * 1000); // 為測試，占用了就不放
               }
            }
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

運行結果:
Tue May 05 10:51:06 CST 2015 LockB 開始執行
Tue May 05 10:51:06 CST 2015 LockA 開始執行
Tue May 05 10:51:06 CST 2015 LockB 鎖住 obj2
Tue May 05 10:51:06 CST 2015 LockA 鎖住 obj1

　　

此時死鎖產生。

為了解決這個問題，我們不使用顯示的去鎖，我們用信號量去控制。

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

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

來看下如下代碼：

import java.util.Date;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

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();
      }
   }
}

　

運行結果：
Tue May 05 10:59:13 CST 2015 LockA 開始執行
Tue May 05 10:59:13 CST 2015 LockB 開始執行
Tue May 05 10:59:13 CST 2015 LockB 鎖住 obj2
Tue May 05 10:59:13 CST 2015 LockA 鎖住 obj1
Tue May 05 10:59:14 CST 2015LockB 鎖 obj1 失敗
Tue May 05 10:59:14 CST 2015LockA 鎖 obj2 失敗
Tue May 05 10:59:15 CST 2015 LockA 鎖住 obj1
Tue May 05 10:59:15 CST 2015 LockA 鎖住 obj2

 

采用lock鎖 使用trylock 獲取鎖，並使用unlock釋放鎖 采用flag控制循環的結束

import java.util.Date;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @description  采用lock 鎖 使用trylock 獲取鎖，並使用unlock釋放鎖 采用flag控制循環的結束
 **/
public class LockTest3 {
    
    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new LockA(),"線程A");
        Thread t2 = new Thread(new LockB(),"線程B");

        t1.start();
        t2.start();
        Thread.sleep(5000);
        System.out.println("主線程結束");
    }

    static class LockA implements Runnable{

        boolean fa = true;
        @Override
        public void run() {
            System.out.println("線程A開始執行"+new Date());
            try {
                while (fa){
                    if (LockTest3.lock1.tryLock(1,TimeUnit.SECONDS)){
                        System.out.println("線程A鎖住lock1"+new Date());
                        if (LockTest3.lock2.tryLock(1,TimeUnit.SECONDS)){
                            System.out.println("線程A鎖住lock2"+new Date());
                            fa =false;
                        }else {
                            System.out.println("線程A鎖住lock2 失敗"+new Date());
                        }
                    }else {
                        System.out.println("線程A鎖住lock1 失敗"+new Date());
                    }

                  /*  lock1.unlock();
                    lock2.unlock();*/
                    System.out.println("當前線程"+Thread.currentThread().getName());
                    if (lock1.isHeldByCurrentThread()){
                        lock1.unlock();
                        System.out.println("線程A釋放lock1");
                    }
                    if (lock2.isHeldByCurrentThread()){
                        lock2.unlock();
                        System.out.println("線程A釋放lock2");
                    }
                    Thread.sleep(2000);
                }
                System.out.println("線程A結束=============");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class LockB implements Runnable{
        boolean fb = true;

        @Override
        public void run() {
            System.out.println("線程B開始執行"+new Date());
            try {
                while (fb){
                    if (LockTest3.lock2.tryLock(1,TimeUnit.SECONDS)){
                        System.out.println("線程B鎖住lock2"+new Date());
                        if (LockTest3.lock1.tryLock(1,TimeUnit.SECONDS)){
                            System.out.println("線程B鎖住lock1"+new Date());
                            fb=false;
                        }else {
                            System.out.println("線程B鎖住lock1 失敗"+new Date());
                        }
                    }else {
                        System.out.println("線程B鎖住lock2 失敗"+new Date());
                    }
                /*    lock1.unlock();
                    lock2.unlock();*/
                    System.out.println("當前線程"+Thread.currentThread().getName());
                    if (lock1.isHeldByCurrentThread()){
                        lock1.unlock();
                        System.out.println("線程B釋放lock1");
                    }
                    if (lock2.isHeldByCurrentThread()){
                        lock2.unlock();
                        System.out.println("線程B釋放lock2");
                    }
                    Thread.sleep(2000);
                }
                System.out.println("線程結束B=============");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}　　

　輸出結果

線程A開始執行Wed Dec 25 11:23:27 CST 2019
線程A鎖住lock1Wed Dec 25 11:23:27 CST 2019
線程A鎖住lock2Wed Dec 25 11:23:27 CST 2019
當前線程線程A
線程A釋放lock1
線程A釋放lock2
線程B開始執行Wed Dec 25 11:23:27 CST 2019
線程B鎖住lock2Wed Dec 25 11:23:27 CST 2019
線程B鎖住lock1Wed Dec 25 11:23:27 CST 2019
當前線程線程B
線程B釋放lock1
線程B釋放lock2
線程A結束=============
線程結束B=============
主線程結束