一、死锁的概念
死锁（英语：deadlock），又译为死结，计算机科学名词。当两个以上的运算单元，双方都在等待对方停止运行，以获取系统资源，但是没有一方提前退出时，就称为死锁。在多任务操作系统中，操作系统为了协调不同行程，能否获取系统资源时，为了让系统正常运作，必须要解决这个问题。另一种相似的情况称为“活锁”。（wiki）
死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。（百度百科）
二、产生死锁的原因
如果系统中只有一个进程，当然不会产生死锁。如果每个进程仅需求一种系统资源，也不会产生死锁。不过这只是理想状态，在现实中是可遇不可求的。
死锁的四个条件是：
- 禁止抢占（no preemption）：系统资源不能被强制从一个进程中退出。
- 持有和等待（hold and wait）：一个进程可以在等待时持有系统资源。
- 互斥（mutual exclusion）：资源只能同时分配给一个行程，无法多个行程共享。
- 循环等待（circular waiting）：一系列进程互相持有其他进程所需要的资源。
死锁只有在四个条件同时满足时发生，预防死锁必须至少破坏其中一项。
产生死锁的原因，主要包括：
- 系统资源不足；
- 程序执行的顺序有问题；
- 资源分配不当等。
三、如何解决死锁
理解了死锁的原因，尤其是产生死锁的四个必要条件，我们就可以最大可能地避免、预防和解除死锁。所以，在系统设计、进程调度等方面注意如何不让这四个必要条件成立，如何确定资源的合理分配算法，避免进程永久占据系统资源，这就是避免、预防和解决死锁的最佳实践。此外，也要防止进程在处于等待状态的情况下占用资源。因此，对资源的分配要给予合理的规划。
四、写一段死锁的代码
1. public class DeadLock { 2. public static final String LOCK_1 = "lock1"; 3. public static final String LOCK_2 = "lock2"; 4. 5. public static void main(String[] args) { 6. Thread threadA = new Thread(() -> { 7. try { 8. while (true) { 9. synchronized (DeadLock.LOCK_1) { 10. System.out.println(Thread.currentThread().getName() + " 锁住 lock1"); 11. Thread.sleep(1000); 12. synchronized (DeadLock.LOCK_2) { 13. System.out.println(Thread.currentThread().getName() + " 锁住 lock2"); 14. } 15. } 16. } 17. } catch (Exception e) { 18. e.printStackTrace(); 19. } 20. }); 21. 22. Thread threadB = new Thread(() -> { 23. try { 24. while (true) { 25. synchronized (DeadLock.LOCK_2) { 26. System.out.println(Thread.currentThread().getName() + " 锁住 lock2"); 27. Thread.sleep(1000); 28. synchronized (DeadLock.LOCK_1) { 29. System.out.println(Thread.currentThread().getName() + " 锁住 lock1"); 30. } 31. } 32. } 33. } catch (Exception e) { 34. e.printStackTrace(); 35. } 36. }); 37. 38. threadA.start(); 39. threadB.start(); 40. } 41. }
如上述代码所示，我们启动了两个线程，在每个线程中都要获得DeadLock.LOCK_1和DeadLock.LOCK_2，其中
threadA，先获取DeadLock.LOCK_1，再获取DeadLock.LOCK_2
threadB，先获取DeadLock.LOCK_2，再获取DeadLock.LOCK_1
这样，当threadA获取到DeadLock.LOCK_1之后，就要去获取DeadLock.LOCK_2，而DeadLock.LOCK_2则是先被threadB获取了，因此threadA就需要等待threadB释放DeadLock.LOCK_2之后才能继续执行；
但是threadB在获取到DeadLock.LOCK_2之后，却是在等待threadA释放DeadLock.LOCK_1，因此这就形成了“循环等待条件”，从而形成了死锁。
想要解决这个死锁很简单，我们只需要让threadA和threadB获取DeadLock.LOCK_1和DeadLock.LOCK_2的顺序相同即可，例如：
1. public class DeadLock { 2. public static final String LOCK_1 = "lock1"; 3. public static final String LOCK_2 = "lock2"; 4. 5. public static void main(String[] args) { 6. Thread threadA = new Thread(() -> { 7. try { 8. while (true) { 9. synchronized (DeadLock.LOCK_1) { 10. System.out.println(Thread.currentThread().getName() + " 锁住 lock1"); 11. Thread.sleep(1000); 12. synchronized (DeadLock.LOCK_2) { 13. System.out.println(Thread.currentThread().getName() + " 锁住 lock2"); 14. } 15. } 16. } 17. } catch (Exception e) { 18. e.printStackTrace(); 19. } 20. }); 21. 22. Thread threadB = new Thread(() -> { 23. try { 24. while (true) { 25. synchronized (DeadLock.LOCK_1) { 26. System.out.println(Thread.currentThread().getName() + " 锁住 lock1"); 27. Thread.sleep(1000); 28. synchronized (DeadLock.LOCK_2) { 29. System.out.println(Thread.currentThread().getName() + " 锁住 lock2"); 30. } 31. } 32. } 33. } catch (Exception e) { 34. e.printStackTrace(); 35. } 36. }); 37. 38. threadA.start(); 39. threadB.start(); 40. } 41. }
参考链接：
