死锁问题详解

￡神魔★判官ぃ 2023-03-06 03:27 20阅读 0赞

**锁**是个非常有用的工具，运用场景非常多，因为它使用起来非常简单，而且易于理解。但  
同时它也会带来一些困扰，那就是可能会引起死锁，一旦产生死锁，就会造成系统功能不可 用。让我们先来看一段代码，**这段代码会引起死锁，使线程t1和线程t2互相等待对方释放锁**。

public class DeadLockDemo {     
            private static String A = "A";    
            private static String B = "B";    
            public static void main(String[] args) {             
                new DeadLockDemo().deadLock();    
            }    
            private void deadLock() {             
                Thread t1 = new Thread(new Runnable() {                     
                    @Override                    
                    public void run() {                             
                        synchronized (A) {                                     
                            try {  
                                Thread.currentThread().sleep(2000);                                    
                            } catch (InterruptedException e) {                                             
                                e.printStackTrace();                                    
                            }                                    
                            synchronized (B) {                                             
                                System.out.println("1");                                    
                            }                            
                        }                    
                    }            
                });            
                Thread t2 = new Thread(new Runnable() {                     
                    @Override                    
                    public void run() {                             
                        synchronized (B) {                                     
                            synchronized (A) {                                             
                                System.out.println("2");                                    
                            }                            
                        }                    
                    }            
                });            
                t1.start();            
                t2.start();    
            } 
        }

> 这段代码只是演示死锁的场景，在现实中你可能不会写出这样的代码。但是，在一些更为 复杂的场景中，你可能会遇到这样的问题，比如t1拿到锁之后，因为一些异常情况没有释放锁 （死循环）。又或者是t1拿到一个数据库锁，释放锁的时候抛出了异常，没释放掉。  
> 一旦出现死锁，业务是可感知的，因为不能继续提供服务了，那么只能通过dump线程查看 到底是哪个线程出现了问题，以下线程信息告诉我们是DeadLockDemo类的第42行和第31行引起的死锁。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyaXN0amNqZG5jZw_size_16_color_FFFFFF_t_70]  
**关于死锁的一些结论：**

*  参与死锁的进程数至少为两个
 *  参与死锁的所有进程均等待资源
 *  参与死锁的进程至少有两个已经占有资源
 *  死锁进程是系统中当前进程集合的一个子集
 *  死锁会浪费大量系统资源，甚至导致系统崩溃。

## 死锁产生的原因 ##

*  **竞争不可抢占资源引起死锁**  
    通常系统中拥有的不可抢占资源，其数量不足以满足多个进程运行的需要，使得进程在运行过程中，会因争夺资源而陷入僵局，如磁带机、打印机等。只有对不可抢占资源的竞争 才可能产生死锁，对可抢占资源的竞争是不会引起死锁的。
 *  **竞争可消耗资源引起死锁**
 *  **进程推进顺序不当引起死锁**  
    进程在运行过程中，请求和释放资源的顺序不当，也同样会导致死锁。例如，并发进程 P1、P2分别保持了资源R1、R2，而进程P1申请资源R2，进程P2申请资源R1时，两者都会因为所需资源被占用而阻塞。  
    信号量使用不当也会造成死锁。进程间彼此相互等待对方发来的消息，结果也会使得这 些进程间无法继续向前推进。例如，进程A等待进程B发的消息，进程B又在等待进程A 发的消息，**可以看出进程A和B不是因为竞争同一资源，而是在等待对方的资源导致死锁**。

## 死锁发生的四个必要条件 ##

虽然进程在运行过程中，可能发生死锁，但死锁的发生也必须具备一定的条件，死锁的发生必须具备以下四个必要条件：

*  **互斥**，共享资源 X 和 Y 只能被一个线程占用；
 *  **占有且等待**，线程 T1 已经取得共享资源 X，在等待共享资源 Y 的时候，不释放共享资源 X；
 *  **不可抢占**，其他线程不能强行抢占线程 T1 占有的资源；
 *  **循环等待**，线程 T1 等待线程 T2 占有的资源，线程 T2 等待线程 T1 占有的资源，就是循环等待

## 处理死锁的方法 ##

*  **预防死锁**：通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或几个条件，来防止死锁的发生。
 *  **避免死锁**：在资源的动态分配过程中，用某种方法去防止系统进入不安全状态，从而避免死锁的发生。
 *  **检测死锁**：允许系统在运行过程中发生死锁，但可设置检测机构及时检测死锁的发生，并采取适当措施加以清除。
 *  **解除死锁**：当检测出死锁后，便采取适当措施将进程从死锁状态中解脱出来。

## 破坏死锁发生的条件预防死锁 ##

> 注意：互斥条件不能被破坏，否则会造成结果的不可再现性。

*  **破坏“占有并等待”条件:**  
    破坏“占有并等待”条件，就是在系统中不允许进程在已获得某种资源的情况下，申请其他资源。即要想出一个办法，阻止进程在持有资源的同时申请其他资源。  
    方法一：创建进程时，要求它申请所需的全部资源，系统或满足其所有要求，或什么也不给它。这是所谓的 “ **一次性分配**”方案。  
    方法二：要求每个进程提出新的资源申请前，释放它所占有的资源。这样，一个进程在需要资源S时，**须先把它先前占有的资源R释放掉，然后才能提出对S的申请**，即使它可能很快又要用到资源R。
 *  **破坏“不可抢占”条件：**  
    破坏“不可抢占”条件就是允许对资源实行抢夺。  
    方法一：如果占有某些资源的一个进程进行进一步资源请求被拒绝，则该进程必须释放它最初占有的资源，如果有必要，可再次请求这些资源和另外的资源。  
    方法二：如果一个进程请求当前被另一个进程占有的一个资源，则操作系统可以抢占另一个进程，要求它释放资源。只有在任意两个进程的优先级都不相同的条件下，方法二才能预防死锁。
 *  **破坏“循环等待”条件：**  
    破坏“循环等待”条件的一种方法，是将系统中的所有资源统一编号，进程可在任何时刻提出资源申请，但所有申请必须按照资源的编号顺序（升序）提出。这样做就能保证系统不出现死锁。

## 避免死锁的常见方法。 ##

*  避免一个线程同时获取多个锁。
 *  避免一个线程在锁内同时占用多个资源，尽量保证每个锁只占用一个资源。
 *  尝试使用定时锁，使用lock.tryLock（timeout）来替代使用内部锁机制。
 *  对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZyaXN0amNqZG5jZw_size_16_color_FFFFFF_t_70]: /images/20230208/afa7d2fae1644f0ba94fcae9e87b2ffa.png