一. 死锁产生的原因并举例说明
为了保护数据的一致性，我们通常对共享数据加锁，阻塞别的线程对数据的修改，修改完数据才能释放锁，别的线程才能获取锁修改数据，这样来保证数据的一致性。
但是多个线程对多个资源进行加锁操作就会导致死锁的产生。
比如下面的这个例子：
public class DeadLockTest { private static Object lockA = new Object(); private static Object lockB = new Object(); public static void main(String[] args) { new Thread(()->{ Thread.currentThread().setName("我是小面1"); synchronized (lockA){ System.out.println(Thread.currentThread().getName() + "：获取到lockA"); //模拟业务 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lockB){ System.out.println(Thread.currentThread().getName() + "：获取到lockb"); //模拟业务 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }).start(); new Thread(() -> { Thread.currentThread().setName("我是小面2"); synchronized (lockB){ System.out.println(Thread.currentThread().getName() + "：获取到lockB"); //模拟业务 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lockA){ System.out.println(Thread.currentThread().getName() + "：获取到lockA"); //模拟业务 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }).start(); } }
运行程序后，一直卡住结束不了。
使用arthus分析： 可以看到确实发生了死锁。
ps: arthus 是很好的一个工具，对排查java程序的故障很有帮助，非常安利大家使用。
看一下死锁产生的条件：
- 互斥条件：锁资源每次只能被一个线程使用；
- 请求与保持条件：一个线程因请求锁资源而阻塞时，对已获得的锁资源保持不放；
- 不剥夺条件:线程已获得的锁资源，在末使用完之前，其他线程不能强行剥夺；
- 循环等待条件:若干线程之间形成一种头尾相接的循环等待锁资源关系；
这四个条件要都同时满足才会导致死锁。我们来看一下上面的例子是怎么满足这四个条件的。
1.互斥条件
synchronized关键字保护的资源，只能又一个线程占用，占用后其他线程不能获取，只能阻塞等待，所以满足互斥条件
2.请求与保持条件
可以看到一个线程需要获取两个锁，一个是lockA,另一个是lockB,获取了其中一个锁后，即使获取不到另外一个锁，也不会释放已获取到的锁资源，所以满足请求与保持条件
3.不剥夺条件:线程已获得的锁资源
synchronized关键字保护的锁，一旦被线程获取，其他线程在它未执行完保护的代码块之前，是不能抢夺该线程获取的锁的，所以满足次条件
4.循环等待条件
上面的例子可以看到java小面1线程占用两个资源的顺序是 lockA -> lockB，而java小面2线程占用资源顺序是相反的 lockB -> lockA,所以会出现循环等待的情况，所以满足循环等待条件
所以同时满足了四个条件，所以发生了死锁。
二.死锁解决办法
由上面得知，我们要同时满足上面四个条件才会导致死锁，所以我们只要破坏四个条件的其中之一就能防止死锁的发生。
破坏条件
我看来看一下，那些条件是不能破坏的，那些是可以破坏的。
- 互斥条件：锁保护的资源，必须只能一个线程获取，如果此条件破坏，达不到保护共享资源的效果。
- 请求与保持条件：我们可以在一个线程获取不到其他资源的时候，主动释放已获取的资源来破坏次条件。
- 不剥夺条件:线程已获得的锁资源：一个线程不能随意争夺其它线程获取到的锁资源，不然也达不到保护共享资源的效果。
- 循环等待条件：我们可以让所有线程获取锁资源的顺序都保持一致，这样就不会产生循环等待，来破坏此条件。
所以我们只能破坏条件2和4，从代码的角度看看怎么解决
破坏：请求与保持条件
public class DeadLockTest2 { private static ReentrantLock lockA = new ReentrantLock(); private static ReentrantLock lockB = new ReentrantLock(); public static void main(String[] args) { new Thread(() -> { Thread.currentThread().setName("我是小面1"); doWork(lockA, lockB); }).start(); new Thread(() -> { Thread.currentThread().setName("我是小面2"); doWork(lockA, lockB); }).start(); } private static void doWork(ReentrantLock lockA, ReentrantLock lockB) { boolean lockFirst = lockA.tryLock(); boolean lockSecond = lockB.tryLock(); while (true) { try { if (lockFirst && lockSecond) { //执行业务A bizA(); //执行业务B bizB(); System.out.println(Thread.currentThread().getName() + ":执行完所有业务"); break; } else { try { Thread.sleep(new Random().nextInt(1000)); } catch (InterruptedException e) { e.printStackTrace(); } } } finally { if (lockFirst) { lockA.unlock(); } if (lockSecond) { lockB.unlock(); } } lockFirst = lockA.tryLock(); lockSecond = lockB.tryLock(); System.out.println(Thread.currentThread().getName() + ":获取锁失败"); } } private static void bizA() { try { Thread.sleep(new Random().nextInt(1000)); } catch (InterruptedException e) { e.printStackTrace(); } } private static void bizB() { try { Thread.sleep(new Random().nextInt(1000)); } catch (InterruptedException e) { e.printStackTrace(); } }
解释一下代码比较关键部分：
- 这次不使用Synchronized关键字，因为Synchronized不能手动释放锁，需要使用ReentrantLock实现
- 同时获取到两个锁，才执行业务
- 如果只获取到其中一个锁，获取不了另一个锁，就释放获取到的锁，然后sleep一段时间后，重新获取。
- 此方法需要循环获取锁，耗费cpu资源，不使用于业务执行时间长的情况。
破坏：循环等待条件
public class DeadLockTest { private static Object lockA = new Object(); private static Object lockB = new Object(); public static void main(String[] args) { List<Object> locks = new ArrayList<>(); locks.add(lockA); locks.add(lockB); locks.sort(Comparator.comparing(Object::hashCode)); Object lockFirst = locks.get(0); //第一个锁 Object lockSecond = locks.get(1);//第二个锁 new Thread(() -> { Thread.currentThread().setName("我是小面1"); doWork(lockFirst, lockSecond); }).start(); new Thread(() -> { doWork(lockFirst, lockSecond); }).start(); } private static void doWork(Object lockFirst, Object lockSecond) { synchronized (lockFirst) { System.out.println(Thread.currentThread().getName() + "：获取到lockFirst"); if(lockFirst == lockA){ //执行业务A bizA(); System.out.println("业务A执行完"); synchronized (lockSecond) { System.out.println(Thread.currentThread().getName() + "：获取到lockSecond"); //执行业务B bizB(); System.out.println(Thread.currentThread().getName() + ":业务B执行完"); } } else{ //执行业务B bizB(); System.out.println("业务B执行完"); synchronized (lockSecond) { System.out.println(Thread.currentThread().getName() + "：获取到lockSecond"); //执行业务A bizA(); System.out.println(Thread.currentThread().getName() + ":业务A执行完"); } } } } private static void bizA(){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } private static void bizB(){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } }
解释一下代码比较关键部分：
- 先对lockA和lockB两个资源排序
- 加锁的时候先对锁判断一下，根据获取到的锁执行对应的业务
- 由于所有线程获取锁的顺序都是一致的。
运行结果：可以看出小面1和小面2线程获取的锁的顺序都是一致的，没有循环等待
三.总结
我们编写代码时尽可能的避免同时获取多个锁资源，导致死锁的发生的先决条件；如果必需要获取多个锁资源，要时刻留意这四个条件，不能同时满足，要破坏二（请求与保持）和四（循环等待）条件之一，这样就可以不发生死锁了。
