活鎖同樣會(huì)發(fā)生在多個(gè)相互協(xié)作的線(xiàn)程間，當(dāng)他們?yōu)榱吮舜碎g的響應(yīng)而相互禮讓?zhuān)沟脹](méi)有一個(gè)線(xiàn)程能夠繼續(xù)前進(jìn)，那么就發(fā)生了活鎖。同死鎖一樣，發(fā)生活鎖的線(xiàn)程無(wú)法繼續(xù)執(zhí)行。

相當(dāng)于兩個(gè)在半路相遇的人：出于禮貌他們相互禮讓?zhuān)荛_(kāi)對(duì)方的路，但是在另一條路上又相遇了。就這樣，不停地一直避讓下去。。。。

死鎖

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

死鎖的四個(gè)必要條件

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

互斥條件

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

請(qǐng)求和保持條件

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

不剝奪條件

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

環(huán)路等待條件

指在發(fā)生死鎖時(shí)，必然存在一個(gè)進(jìn)程——資源的環(huán)形鏈，即進(jìn)程集合{A，B，C，···，Z} 中的A正在等待一個(gè)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 線(xiàn)程調(diào)度先執(zhí)行哪個(gè)線(xiàn)程是不確定的。
    // lockWater 的 run() 可能在 lockBread 的 run() 之前運(yùn)行
    new Thread(lockBread).start();
    new Thread(lockWater).start();
  }
}

程序運(yùn)行結(jié)果：

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

死鎖排查

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

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，粘貼進(jìn)程號(hào) 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)一個(gè)死鎖；
Thread-1 locked <0x000000076bf9e3e8> waiting to lock <0x000000076bf9e3d8>：線(xiàn)程1，鎖住了 0x000000076bf9e3e8 等待 0x000000076bf9e3d8 鎖；
Thread-0 locked <0x000000076bf9e3d8> waiting to lock <0x000000076bf9e3e8>：線(xiàn)程0，鎖住了 0x000000076bf9e3d8 等待 0x000000076bf9e3e8 鎖；

總結(jié)一下

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

如何避免死鎖

預(yù)防死鎖

其實(shí)就是破壞死鎖的四個(gè)必要條件?。?！

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

設(shè)置加鎖順序

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

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

@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("喝完水，面包也吃完了。。。");
        }
    }
}

程序運(yùn)行結(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);
              // 如果沒(méi)有獲取到 water 鎖，釋放 bread 鎖，再次嘗試！
              if (!w) {
                bread.unlock();
                continue;
              }
              System.out.println("拿到水了");
              break;
            }
            System.out.println("吃面包，喝水！");
          } catch (InterruptedException e) {
            System.out.println("線(xiàn)程中斷");
          } 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);
              // 如果沒(méi)有獲取到 bread 鎖，釋放 water 鎖，再次嘗試！
              if (!b) {
                water.unlock();
                continue;
              }
              System.out.println("拿到面包了");
              break;
            }
            System.out.println("喝水，吃面包！");
          } catch (InterruptedException e) {
            System.out.println("線(xiàn)程中斷");
          } finally {
            bread.unlock();
            water.unlock();
          }
        });
    executorService.shutdown();
  }
}

程序運(yùn)行結(jié)果：

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

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

解決活鎖

鎖讓出的時(shí)候添加隨機(jī)睡眠時(shí)間

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

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);
              // 如果沒(méi)有獲取到 water 鎖，釋放 bread 鎖，再次嘗試！
              if (!w) {
                bread.unlock();
                continue;
              }
              System.out.println("拿到水了");
              break;
            }
            System.out.println("吃面包，喝水！");
          } catch (InterruptedException e) {
            System.out.println("線(xiàn)程中斷");
          } 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);
                // 如果沒(méi)有獲取到 bread 鎖，釋放 water 鎖，再次嘗試！
                if (!b) {
                    water.unlock();
                    continue;
                }
                System.out.println("拿到面包了");
                break;
            }
            System.out.println("喝水，吃面包！");
        } catch (InterruptedException e) {
            System.out.println("線(xiàn)程中斷");
        } finally {
            bread.unlock();
            water.unlock();
        }
    });
executorService.shutdown();

程序輸出結(jié)果：