死锁产生条件

死锁的产生必须具备以下四个条件：

条件
互斥 指线程对已经获取到的资源进行排它性使用，即该资源同时只由一个线程占用。如果此时还有其他线程请求获取该资源，则请求者只能等待，直至占有资源的线程释放该资源。
占有且等待 指一个线程已经持有了至少一个资源，但又提出了新的资源请求，而新资源已被其他线程占有，所以当前线程会被阻塞，但阻塞的同时并不释放自己已经获取的资源。
不可抢占 指线程获取到的资源在自己使用完之前不能被其他线程抢占，只有在自己使用完毕后才由自己释放该资源。
循环等待 指在发生死锁时，必然存在一个线程—资源的环形链，即线程集合{T0, T1, T2, …, Tn}中的T0正在等待一个T1占用的资源，T1正在等待T2占用的资源，……Tn正在等待已被T0占用的资源 
  1. package com.example.thread;
  3. /**
  4.  * @Description:
  5.  * @Author: baxiang
  6.  * @Date: 2021/9/28.
  7.  */
  9. public class DeadLockTest {
  10.     //1. 创建共享资源
  11.     private static Object resourceA = new Object();
  12.     private static Object resourceB = new Object();
  14.     public static void main(String[] args) {
  16.         //2. 创建线程A
  17.         Thread threadA = new Thread(new Runnable() {
  18.             @Override
  19.             public void run() {
  20.                 //2.1获取资源A的锁
  21.                 synchronized (resourceA) {
  22.                     System.out.println(Thread.currentThread() + " get ResourceA");
  23.                     try {
  24.                         Thread.sleep(1000);
  25.                     } catch (InterruptedException e) {
  26.                         e.printStackTrace();
  27.                     }
  29.                     //2.1获取资源B的锁
  30.                     System.out.println(Thread.currentThread() + "waiting get ResourceB");
  31.                     synchronized (resourceB) {
  32.                         System.out.println(Thread.currentThread() + "get ResourceB");
  33.                     }
  34.                 }
  35.             }
  36.         });
  38.         //3. 创建线程B
  39.         Thread threadB = new Thread(new Runnable() {
  40.             @Override
  41.             public void run() {
  42.                 //3.1获取资源B的锁
  43.                 synchronized (resourceB) {
  44.                     System.out.println(Thread.currentThread() + " get ResourceB");
  46.                     try {
  47.                         Thread.sleep(1000);
  48.                     } catch (InterruptedException e) {
  49.                         e.printStackTrace();
  50.                     }
  51.                     //3.2获取资源A的锁
  52.                     System.out.println(Thread.currentThread() + "waiting get ResourceA");
  53.                     synchronized (resourceA) {
  54.                         System.out.println(Thread.currentThread() + "get ResourceA");
  55.                     }
  56.                 }
  57.                 ;
  58.             }
  59.         });
  61.         //3. 启动线程
  62.         threadA.start();
  63.         threadB.start();
  64.     }
  65. }

避免线程死锁

互斥这个条件我们没有办法破坏，因为我们用锁为的就是互斥，其他三个条件都有办法可以破坏
对于“占用且等待”这个条件，我们可以一次性申请所有的资源，这样就不存在等待了。
对于“不可抢占”这个条件，占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动
释放它占有的资源，这样不可抢占这个条件就破坏掉了。
对于“循环等待”这个条件，可以靠按序申请资源来预防。所谓按序申请，是指资源是有线性顺序
的，申请的时候可以先申请资源序号小的，再申请资源序号大的，这样线性化后自然就不存在循环
了。

目前只有请求并持有和环路等待条件是可以被破坏的。

  1. public class DeadLockBrokenTest {
  2.     //1. 创建共享资源
  3.     private static Object resourceA = new Object();
  4.     private static Object resourceB = new Object();
  6.     public static void main(String[] args) {
  8.         //2. 创建线程A
  9.         Thread threadA = new Thread(new Runnable() {
  10.             @Override
  11.             public void run() {
  12.                 //2.1获取资源A的锁
  13.                 synchronized (resourceA) {
  14.                     System.out.println(Thread.currentThread() + " get ResourceA");
  15.                     try {
  16.                         Thread.sleep(1000);
  17.                     } catch (InterruptedException e) {
  18.                         e.printStackTrace();
  19.                     }
  21.                     //2.1获取资源B的锁
  22.                     System.out.println(Thread.currentThread() + "waiting get ResourceB");
  23.                     synchronized (resourceB) {
  24.                         System.out.println(Thread.currentThread() + "get ResourceB");
  25.                     }
  26.                 }
  27.             }
  28.         });
  30.         //3. 创建线程B
  31.         Thread threadB = new Thread(new Runnable() {
  32.             @Override
  33.             public void run() {
  34.                 //3.1获取资源A的锁
  35.                 synchronized (resourceA) {
  36.                     System.out.println(Thread.currentThread() + " get ResourceA");
  38.                     try {
  39.                         Thread.sleep(1000);
  40.                     } catch (InterruptedException e) {
  41.                         e.printStackTrace();
  42.                     }
  43.                     //3.2获取资源B的锁
  44.                     System.out.println(Thread.currentThread() + "waiting get ResourceB");
  45.                     synchronized (resourceB) {
  46.                         System.out.println(Thread.currentThread() + "get ResourceB");
  47.                     }
  48.                 }
  49.             }
  50.         });
  52.         //3. 启动线程
  53.         threadA.start();
  54.         threadB.start();
  55.     }
  56. }