如何避免死锁

死锁发生的条件 互斥，共享资源只能被一个线程占用 占有且等待，线程 t1 已经取得共享资源 s1，尝试获取共享资源 s2 的时候，不释放共享资源 s1 不可抢占，其他线程不能强行抢占线程 t1 占有的资源 s1 循环等待，线程 t1 等待线程 t2 占有的资源，线程 t2 等待线程 t1 占有的资源 避免死锁的方法 对于以上 4 个条件，只要破坏其中一个条件，就可以避免死锁的发生。 对于第一个条件 "互斥" 是不能破坏的，因为加锁就是为了保证互斥。 其他三个条件，我们可以尝试 一次性申请所有的资源，破坏 "占有且等待" 条件 占有部分资源的线程进一步申请其他资源时，如果申请不到，主动释放它占有的资源，破坏 "不可抢占" 条件 按序申请资源，破坏 "循环等待" 条件 使用管理类一次性申请所有的资源，破坏 "占有且等待" 条件示例 [Java] 纯文本查看 复制代码 ? 001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 016 017 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 package constxiong.concurrency.a023; import java.util.HashSet; import java.util.Set; /**  * 测试 一次性申请所有的资源，破坏 "占有且等待" 条件示例  * @author ConstXiong  * @date 2019-09-24 14:04:12  */ public class TestBreakLockAndWait {            //单例的资源管理类         private final static Manger manager = new Manger();                   //资源1         private static Object res1 = new Object();                   //资源2         private static Object res2 = new Object();                   public static void main(String[] args) {                 new Thread(() -> {                         boolean applySuccess = false;                         while (!applySuccess) {                                 //向管理类，申请res1和res2,申请失败，重试                                 applySuccess = manager.applyResources(res1, res2);                                 if (applySuccess) {                                         try {                                                 System.out.println("线程：" + Thread.currentThread().getName() + " 申请 res1、res2 资源成功");                                                 synchronized (res1) {                                                         System.out.println("线程：" + Thread.currentThread().getName() + " 获取到 res1 资源的锁");                                                         //休眠 1秒                                                         try {                                                                 Thread.sleep(1000);                                                         } catch (Exception e) {                                                                 e.printStackTrace();                                                         }                                                         synchronized (res2) {                                                                 System.out.println("线程：" + Thread.currentThread().getName() + " 获取到 res2 资源的锁");                                                         }                                                 }                                         } finally {                                                 manager.returnResources(res1, res2);//归还资源                                         }                                 } else {                                         System.out.println("线程：" + Thread.currentThread().getName() + " 申请 res1、res2 资源失败");                                         //申请失败休眠 200 毫秒后重试                                         try {                                                 Thread.sleep(200);                                         } catch (Exception e) {                                                 e.printStackTrace();                                         }                                 }                         }                 }).start();                                   new Thread(() -> {                         boolean applySuccess = false;                         while (!applySuccess) {                                 //向管理类，申请res1和res2,申请失败，重试                                 applySuccess = manager.applyResources(res1, res2);                                 if (applySuccess) {                                         try {                                                 System.out.println("线程：" + Thread.currentThread().getName() + " 申请 res1、res2 资源成功");                                                 synchronized (res2) {                                                         System.out.println("线程：" + Thread.currentThread().getName() + " 获取到 res1 资源的锁");                                                         //休眠 1秒                                                         try {                                                                 Thread.sleep(1000);                                                         } catch (Exception e) {                                                                 e.printStackTrace();                                                         }                                                         synchronized (res1) {                                                                 System.out.println("线程：" + Thread.currentThread().getName() + " 获取到 res2 资源的锁");                                                         }                                                 }                                         } finally {                                                 manager.returnResources(res1, res2);//归还资源                                         }                                 } else {                                         System.out.println("线程：" + Thread.currentThread().getName() + " 申请 res1、res2 资源失败");                                         //申请失败休眠 200 毫秒后重试                                         try {                                                 Thread.sleep(200);                                         } catch (Exception e) {                                                 e.printStackTrace();                                         }                                 }                         }                 }).start();                           }           }    /**  * 资源申请、归还管理类  * @author ConstXiong  * @date 2019-09-24 14:10:57  */ class Manger {                   //资源存放集合         private Set<Object> resources = new HashSet<Object>();                   /**          * 申请资源          * @param res1          * @param res2          * @return          */         synchronized boolean applyResources(Object res1, Object res2) {                 if (resources.contains(res1) || resources.contains(res1)) {                         return false;                 } else {                         resources.add(res1);                         resources.add(res2);                         return true;                 }         }                   /**          * 归还资源          * @param res1          * @param res2          */         synchronized void returnResources(Object res1, Object res2) {                 resources.remove(res1);                 resources.remove(res2);         }           } 打印结果如下，线程-1 在线程-0 释放完资源后才能成功申请 res1 和 res2 的锁 [Java] 纯文本查看 复制代码 ? 01 02 03 04 05 06 07 08 09 10 11 12 线程：Thread-0 申请 res1、res2 资源成功 线程：Thread-0 获取到 res1 资源的锁 线程：Thread-1 申请 res1、res2 资源失败 线程：Thread-1 申请 res1、res2 资源失败 线程：Thread-1 申请 res1、res2 资源失败 线程：Thread-1 申请 res1、res2 资源失败 线程：Thread-1 申请 res1、res2 资源失败 线程：Thread-0 获取到 res2 资源的锁 线程：Thread-1 申请 res1、res2 资源失败 线程：Thread-1 申请 res1、res2 资源成功 线程：Thread-1 获取到 res1 资源的锁 线程：Thread-1 获取到 res2 资源的锁 使用 Lock 的 tryLock() 方法，获取锁失败释放所有资源，破坏 "不可抢占" 条件示例 [Java] 纯文本查看 复制代码 ? 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 package constxiong.concurrency.a023;    import java.util.Random; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;    /**  * 测试 占有部分资源的线程进一步申请其他资源时，如果申请不到，主动释放它占有的资源，破坏 "不可抢占" 条件  * @author ConstXiong  * @date 2019-09-24 14:50:51  */ public class TestBreakLockOccupation {                   private static Random r = new Random();            private static Lock lock1 = new ReentrantLock();                   private static Lock lock2 = new ReentrantLock();                   public static void main(String[] args) {                 new Thread(() -> {                         //标识任务是否完成                         boolean taskComplete = false;                         while (!taskComplete) {                                 lock1.lock();                                 System.out.println("线程：" + Thread.currentThread().getName() + " 获取锁 lock1 成功");                                 try {                                         //随机休眠，帮助造成死锁环境                                         try {                                                 Thread.sleep(r.nextInt(30));                                         } catch (Exception e) {                                                 e.printStackTrace();                                         }                                                                                   //线程 0 尝试获取 lock2                                         if (lock2.tryLock()) {                                                 System.out.println("线程：" + Thread.currentThread().getName() + " 获取锁 lock2 成功");                                                 try {                                                         taskComplete = true;                                                 } finally {                                                         lock2.unlock();                                                 }                                         } else {                                                 System.out.println("线程：" + Thread.currentThread().getName() + " 获取锁 lock2 失败");                                         }                                 } finally {                                         lock1.unlock();                                 }                                                                   //随机休眠，避免出现活锁                                 try {                                         Thread.sleep(r.nextInt(10));                                 } catch (Exception e) {                                         e.printStackTrace();                                 }                         }                 }).start();                                   new Thread(() -> {                         //标识任务是否完成                         boolean taskComplete = false;                         while (!taskComplete) {                                 lock2.lock();                                 System.out.println("线程：" + Thread.currentThread().getName() + " 获取锁 lock2 成功");                                 try {                                         //随机休眠，帮助造成死锁环境                                         try {                                                 Thread.sleep(r.nextInt(30));                                         } catch (Exception e) {                                                 e.printStackTrace();                                         }                                                                                   //线程2 尝试获取锁 lock1                                         if (lock1.tryLock()) {                                                 System.out.println("线程：" + Thread.currentThread().getName() + " 获取锁 lock1 成功");                                                 try {                                                         taskComplete = true;                                                 } finally {                                                         lock1.unlock();                                                 }                                         } else {                                                 System.out.println("线程：" + Thread.currentThread().getName() + " 获取锁 lock1 失败");                                         }                                 } finally {                                         lock2.unlock();                                 }                                                                   //随机休眠，避免出现活锁                                 try {                                         Thread.sleep(r.nextInt(10));                                 } catch (Exception e) {                                         e.printStackTrace();                                 }                         }                 }).start();         }           } 打印结果如下 [Java] 纯文本查看 复制代码 ? 1 2 3 4 5 6 7 8 线程：Thread-0 获取锁 lock1 成功 线程：Thread-1 获取锁 lock2 成功 线程：Thread-1 获取锁 lock1 失败 线程：Thread-1 获取锁 lock2 成功 线程：Thread-0 获取锁 lock2 失败 线程：Thread-1 获取锁 lock1 成功 线程：Thread-0 获取锁 lock1 成功 线程：Thread-0 获取锁 lock2 成功 按照一定的顺序加锁，破坏 "循环等待" 条件示例 [Java] 纯文本查看 复制代码 ? 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 package constxiong.concurrency.a023;    /**  * 测试 按序申请资源，破坏 "循环等待" 条件  * @author ConstXiong  * @date 2019-09-24 15:26:23  */ public class TestBreakLockCircleWait {            private static Object res1 = new Object();                   private static Object res2 = new Object();                             public static void main(String[] args) {                 new Thread(() -> {                         Object first = res1;                         Object second = res2;                         //比较 res1 和 res2 的 hashCode,如果 res1 的 hashcode > res2，交换 first 和 second。保证 hashCode 小的对象先加锁                         if (res1.hashCode() > res2.hashCode()) {                                 first = res2;                                 second = res1;                         }                         synchronized (first) {                                 System.out.println("线程：" + Thread.currentThread().getName() + "获取资源 " + first + " 锁成功");                                 try {                                         Thread.sleep(100);                                 } catch (Exception e) {                                         e.printStackTrace();                                 }                                 synchronized(second) {                                         System.out.println("线程：" + Thread.currentThread().getName() + "获取资源 " + second + " 锁成功");                                 }                         }                 }).start();                                   new Thread(() -> {                         Object first = res1;                         Object second = res2;                         //比较 res1 和 res2 的 hashCode,如果 res1 的 hashcode > res2，交换 first 和 second。保证 hashCode 小的对象先加锁                         if (res1.hashCode() > res2.hashCode()) {                                 first = res2;                                 second = res1;                         }                         synchronized (first) {                                 System.out.println("线程：" + Thread.currentThread().getName() + "获取资源 " + first + " 锁成功");                                 try {                                         Thread.sleep(100);                                 } catch (Exception e) {                                         e.printStackTrace();                                 }                                 synchronized(second) {                                         System.out.println("线程：" + Thread.currentThread().getName() + "获取资源 " + second + " 锁成功");                                 }                         }                 }).start();         }           } 打印结果如下 [Java] 纯文本查看 复制代码 ? 1 2 3 4 线程：Thread-0获取资源 java.lang.Object@7447157c 锁成功 线程：Thread-0获取资源 java.lang.Object@7a80f45c 锁成功 线程：Thread-1获取资源 java.lang.Object@7447157c 锁成功 线程：Thread-1获取资源 java.lang.Object@7a80f45c 锁成功