快捷導(dǎo)航

Java中死鎖與活鎖的具體實現(xiàn)

更新時間：2022年05月07日 10:29:36 作者：九七年生于初夏

鎖發(fā)生在不同的請求中，本文主要介紹了Java中死鎖與活鎖，文中通過示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下

活鎖與死鎖

活鎖

活鎖同樣會發(fā)生在多個相互協(xié)作的線程間，當(dāng)他們?yōu)榱吮舜碎g的響應(yīng)而相互禮讓，使得沒有一個線程能夠繼續(xù)前進，那么就發(fā)生了活鎖。同死鎖一樣，發(fā)生活鎖的線程無法繼續(xù)執(zhí)行。

相當(dāng)于兩個在半路相遇的人：出于禮貌他們相互禮讓，避開對方的路，但是在另一條路上又相遇了。就這樣，不停地一直避讓下去。。。。

死鎖

兩個或更多線程阻塞著等待其它處于死鎖狀態(tài)的線程所持有的鎖。死鎖通常發(fā)生在多個線程同時但以不同的順序請求同一組鎖的時候，死鎖會讓你的程序掛起無法完成任務(wù)。

死鎖的四個必要條件

在 Java 中使用多線程，就會有可能導(dǎo)致死鎖問題。死鎖會讓程序一直卡住，不再程序往下執(zhí)行。我們只能通過中止并重啟的方式來讓程序重新執(zhí)行。這是我們非常不愿意看到的一種現(xiàn)象，我們要盡可能避免死鎖的情況發(fā)生！

互斥條件

指進程對所分配到的資源進行排它性使用，即在一段時間內(nèi)某資源只由一個進程占用。如果此時還有其它進程請求資源，則請求者只能等待，直至占有資源的進程用完釋放。

請求和保持條件

指進程已經(jīng)保持至少一個資源，但又提出了新的資源請求，而該資源已被其它進程占有，此時請求進程阻塞，但又對自己已獲得的其它資源保持不放。

不剝奪條件

指進程已獲得的資源，在未使用完之前，不能被剝奪，只能在使用完時由自己釋放。

環(huán)路等待條件

指在發(fā)生死鎖時，必然存在一個進程——資源的環(huán)形鏈，即進程集合{A，B，C，···，Z} 中的A正在等待一個B占用的資源；B正在等待C占用的資源，……，Z正在等待已被A占用的資源。

死鎖示例

/** @author Strive */
@SuppressWarnings("all")
public class DeadLock implements Runnable {
  public int flag = 1;

  /** 面包 */
  private static final Object bread = new Object();

  /** 水 */
  private static final Object water = new Object();

  @Override
  public void run() {
    if (flag == 1) {
      // 先吃面包再喝水，環(huán)路等待條件
      synchronized (bread) {
        try {
          Thread.sleep(500);
        } catch (Exception e) {
          e.printStackTrace();
        }
        System.out.println("面包吃了，等喝水。。。");
        synchronized (water) {
          System.out.println("面包吃了，水也喝到了");
        }
      }
    }
    if (flag == 0) {
      // 先喝水再吃面包，環(huán)路等待條件
      synchronized (water) {
        try {
          Thread.sleep(500);
        } catch (Exception e) {
          e.printStackTrace();
        }
        System.out.println("喝完水，等吃面包了。。。");
        synchronized (bread) {
          System.out.println("喝完水，面包也吃完了。。。");
        }
      }
    }
  }

  public static void main(String[] args) {
    DeadLock lockBread = new DeadLock();
    DeadLock lockWater = new DeadLock();
    lockBread.flag = 1;
    lockWater.flag = 0;
    // lockBread,lockWater 都處于可執(zhí)行狀態(tài)，但 JVM 線程調(diào)度先執(zhí)行哪個線程是不確定的。
    // lockWater 的 run() 可能在 lockBread 的 run() 之前運行
    new Thread(lockBread).start();
    new Thread(lockWater).start();
  }
}

程序運行結(jié)果：

喝完水，等吃面包了。。。
面包吃了，等喝水。。。

死鎖排查

先執(zhí)行上面的代碼，再進行排查！

1、使用 jps -l

D:\workspace-code\gitee\dolphin>jps -l
7072 org.jetbrains.jps.cmdline.Launcher
8824 sun.tools.jps.Jps
17212
4012 com.dolphin.thread.locks.DeadLock
6684 org.jetbrains.idea.maven.server.RemoteMavenServer36

4012 com.dolphin.thread.locks.DeadLock，粘貼進程號 4012

2、使用 jstack 4012

... ...
Java stack information for the threads listed above:
===================================================
"Thread-1":
        at com.dolphin.thread.locks.DeadLock.run(DeadLock.java:40)
        - waiting to lock <0x000000076bf9e3d8> (a java.lang.Object)
        - locked <0x000000076bf9e3e8> (a java.lang.Object)
        at java.lang.Thread.run(Thread.java:748)
"Thread-0":
        at com.dolphin.thread.locks.DeadLock.run(DeadLock.java:26)
        - waiting to lock <0x000000076bf9e3e8> (a java.lang.Object)
        - locked <0x000000076bf9e3d8> (a java.lang.Object)
        at java.lang.Thread.run(Thread.java:748)

Found 1 deadlock.

從打印信息我們可以看出：

Found 1 deadlock：發(fā)現(xiàn)一個死鎖；
Thread-1 locked <0x000000076bf9e3e8> waiting to lock <0x000000076bf9e3d8>：線程1，鎖住了 0x000000076bf9e3e8 等待 0x000000076bf9e3d8 鎖；
Thread-0 locked <0x000000076bf9e3d8> waiting to lock <0x000000076bf9e3e8>：線程0，鎖住了 0x000000076bf9e3d8 等待 0x000000076bf9e3e8 鎖；

總結(jié)一下

當(dāng) DeadLock 類的對象 flag=1 時（lockBread），先鎖定 bread，睡眠500毫秒；
而 lockBread 在睡眠的時候另一個 flag==0 的對象（lockWater）線程啟動，先鎖定 water，睡眠500毫秒；
lockBread 睡眠結(jié)束后需要鎖定 water 才能繼續(xù)執(zhí)行，而此時 water 已被 lockWater 鎖定；
lockWater 睡眠結(jié)束后需要鎖定 bread 才能繼續(xù)執(zhí)行，而此時 bread 已被 lockBread 鎖定；
lockBread、lockWater 相互等待，都需要得到對方鎖定的資源才能繼續(xù)執(zhí)行，從而死鎖；

如何避免死鎖

預(yù)防死鎖

其實就是破壞死鎖的四個必要條件?。。?/p>

破壞互斥條件：使資源同時訪問而非互斥使用，就沒有進程會阻塞在資源上，從而不發(fā)生死鎖。
破壞請求和保持條件：采用靜態(tài)分配的方式，靜態(tài)分配的方式是指進程必須在執(zhí)行之前就申請需要的全部資源，且直至所要的資源全部得到滿足后才開始執(zhí)行，只要有一個資源得不到分配，也不給這個進程分配其他的資源。
破壞不剝奪條件：即當(dāng)某進程獲得了部分資源，但得不到其它資源，則釋放已占有的資源，但是只適用于內(nèi)存和處理器資源。
破壞循環(huán)等待條件：給系統(tǒng)的所有資源編號，規(guī)定進程請求所需資源的順序必須按照資源的編號依次進行。

設(shè)置加鎖順序

兩個線程試圖以不同的順序來獲得相同的鎖，如果按照相同的順序來請求鎖，那么就不會出現(xiàn)循環(huán)的加鎖依賴性，因此也就不會產(chǎn)生死鎖，每個需要鎖面包和鎖水的線程都以相同的順序來獲取面包和水，那么就不會發(fā)生死鎖了，如下圖所示：

根據(jù)上圖我們修改一下之前寫的死鎖代碼，消除死鎖！

@Override
public void run() {
    if (flag == 1) {
        // 先吃面包再喝水，環(huán)路等待條件
        synchronized (bread) {
            try {
                Thread.sleep(500);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("面包吃了，等喝水。。。");
        }

        synchronized (water) {
            System.out.println("面包吃了，水也喝到了");
        }
    }
    if (flag == 0) {
        // 先喝水再吃面包，環(huán)路等待條件
        synchronized (water) {
            try {
                Thread.sleep(500);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("喝完水，等吃面包了。。。");
        }

        synchronized (bread) {
            System.out.println("喝完水，面包也吃完了。。。");
        }
    }
}

程序運行結(jié)果：

喝完水，等吃面包了。。。
面包吃了，等喝水。。。
面包吃了，水也喝到了
喝完水，面包也吃完了。。。

這樣就可以消除死鎖發(fā)生~~~

活鎖示例

import java.lang.management.ManagementFactory;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/** @author Strive */
public class LiveLock {
  static ReentrantLock bread = new ReentrantLock();
  static ReentrantLock water = new ReentrantLock();

  public static void main(String[] args) {
    String name = ManagementFactory.getRuntimeMXBean().getName();
    String pid = name.split("@")[0];
    System.out.println("Pid is:" + pid);
    System.out.println("jstack " + pid);

    ExecutorService executorService = Executors.newCachedThreadPool();

    executorService.submit(
        () -> {
          try {
            // 嘗試獲得 bread 鎖
            while (bread.tryLock(10, TimeUnit.SECONDS)) {
              System.out.println("拿到面包了，等著拿水。。。");
              TimeUnit.SECONDS.sleep(1);

              // 判斷 water 是否被鎖住，如果鎖住，退出！再次嘗試獲取 water 鎖
              boolean locked = water.isLocked();
              if (locked) {
                bread.unlock();
                continue;
              }

              // 嘗試獲得 water 鎖
              boolean w = water.tryLock(10, TimeUnit.SECONDS);
              // 如果沒有獲取到 water 鎖，釋放 bread 鎖，再次嘗試！
              if (!w) {
                bread.unlock();
                continue;
              }
              System.out.println("拿到水了");
              break;
            }
            System.out.println("吃面包，喝水！");
          } catch (InterruptedException e) {
            System.out.println("線程中斷");
          } finally {
            water.unlock();
            bread.unlock();
          }
        });

    executorService.submit(
        () -> {
          try {
            while (water.tryLock(10, TimeUnit.SECONDS)) {
              System.out.println("拿到水了，等著拿面包。。。");
              TimeUnit.SECONDS.sleep(2);

              // 判斷 bread 是否被鎖住，如果鎖住，退出！再次嘗試獲取 bread 鎖
              boolean locked = bread.isLocked();
              if (locked) {
                water.unlock();
                continue;
              }

              // 嘗試獲得 bread 鎖
              boolean b = bread.tryLock(10, TimeUnit.SECONDS);
              // 如果沒有獲取到 bread 鎖，釋放 water 鎖，再次嘗試！
              if (!b) {
                water.unlock();
                continue;
              }
              System.out.println("拿到面包了");
              break;
            }
            System.out.println("喝水，吃面包！");
          } catch (InterruptedException e) {
            System.out.println("線程中斷");
          } finally {
            bread.unlock();
            water.unlock();
          }
        });
    executorService.shutdown();
  }
}

程序運行結(jié)果：

Pid is:8788
jstack 8788
拿到面包了，等著拿水。。。
拿到水了，等著拿面包。。。
拿到面包了，等著拿水。。。
拿到水了，等著拿面包。。。
拿到面包了，等著拿水。。。
拿到面包了，等著拿水。。。
拿到水了，等著拿面包。。。

已經(jīng)輸出打印了 Pid，嘗試自己用 jstack 調(diào)試一下吧！可以參考如何排查死鎖的章節(jié)~

解決活鎖

鎖讓出的時候添加隨機睡眠時間

修改上面的程序，參考下面的代碼：

executorService.submit(
        () -> {
          try {
            // 嘗試獲得 bread 鎖
            while (bread.tryLock(10, TimeUnit.SECONDS)) {
              System.out.println("拿到面包了，等著拿水。。。");
              TimeUnit.SECONDS.sleep(1);

              // 判斷 water 是否被鎖住，如果鎖住，退出！再次嘗試獲取 water 鎖
              boolean locked = water.isLocked();
              if (locked) {
                bread.unlock();
                // 避免活鎖
                TimeUnit.MILLISECONDS.sleep(1000);
                continue;
              }

              // 嘗試獲得 water 鎖
              boolean w = water.tryLock(10, TimeUnit.SECONDS);
              // 如果沒有獲取到 water 鎖，釋放 bread 鎖，再次嘗試！
              if (!w) {
                bread.unlock();
                continue;
              }
              System.out.println("拿到水了");
              break;
            }
            System.out.println("吃面包，喝水！");
          } catch (InterruptedException e) {
            System.out.println("線程中斷");
          } finally {
            water.unlock();
            bread.unlock();
          }
        });

executorService.submit(
    () -> {
        try {
            while (water.tryLock(10, TimeUnit.SECONDS)) {
                System.out.println("拿到水了，等著拿面包。。。");
                TimeUnit.SECONDS.sleep(2);

                // 判斷 bread 是否被鎖住，如果鎖住，退出！再次嘗試獲取 bread 鎖
                boolean locked = bread.isLocked();
                if (locked) {
                    water.unlock();
                    // 避免活鎖
                    TimeUnit.MILLISECONDS.sleep(1500);
                    continue;
                }

                // 嘗試獲得 bread 鎖
                boolean b = bread.tryLock(10, TimeUnit.SECONDS);
                // 如果沒有獲取到 bread 鎖，釋放 water 鎖，再次嘗試！
                if (!b) {
                    water.unlock();
                    continue;
                }
                System.out.println("拿到面包了");
                break;
            }
            System.out.println("喝水，吃面包！");
        } catch (InterruptedException e) {
            System.out.println("線程中斷");
        } finally {
            bread.unlock();
            water.unlock();
        }
    });
executorService.shutdown();

程序輸出結(jié)果：