/** @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é)一下

當 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ù)防死鎖

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

破壞互斥條件：使資源同時訪問而非互斥使用，就沒有進程會阻塞在資源上，從而不發(fā)生死鎖。
破壞請求和保持條件：采用靜態(tài)分配的方式，靜態(tài)分配的方式是指進程必須在執(zhí)行之前就申請需要的全部資源，且直至所要的資源全部得到滿足后才開始執(zhí)行，只要有一個資源得不到分配，也不給這個進程分配其他的資源。
破壞不剝奪條件：即當某進程獲得了部分資源，但得不到其它資源，則釋放已占有的資源，但是只適用于內(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é)果：