二十五. 并发实战-构造死锁

阳光穿透心脏的1/2处 2024-03-30 17:59 53阅读 0赞

### 前言 ###

本篇文章将对`死锁的产生`和`死锁的构造`进行说明。

### 正文 ###

#### 一. 死锁的产生 ####

产生死锁的条件如下所示。

1.  `互斥`。共享资源**X**和**Y**只能同时被一个线程占有；
2.  `占有且等待`。线程**T1**已经占有共享资源**X**，在等待共享资源**Y**的时候，不释放共享资源**X**，线程**T2**已经占有共享资源**Y**，在等待共享资源**X**的时候，不释放共享资源**Y**；
3.  `不可抢占`。其它线程不能强行抢占线程占有的资源；
4.  `循环等待`。线程**T1**等待线程**T2**占有的资源，线程**T2**等待线程**T1**占有的资源。

#### 二. 死锁的解决 ####

**破环产生死锁的条件中的任意一个**。

**注意**：`互斥`不可破坏。

#### 三. 死锁的构造 ####

下面是一个示例，演示什么情况下会形成死锁。

public class ReentrantLockTest {
        
    
        @Test
        public void 测试死锁() throws Exception {
        
            // 创建锁对象
            Lock lock2 = new ReentrantLock();
            Lock lock1 = new ReentrantLock();
    
            // 创建CountdownLatch
            CountDownLatch countDownLatch = new CountDownLatch(2);
    
            // 任务1：先获取lock1，然后睡眠2秒，再获取lock2
            Runnable runnable1 = new Runnable() {
        
                @Override
                public void run() {
        
                    lock1.lock();
                    try {
        
                        Thread.sleep(2000);
                        lock2.lock();
                        try {
        
                            System.out.println("先获取锁1再获取锁2");
                        } finally {
        
                            lock2.unlock();
                        }
                    } catch (InterruptedException e) {
        
                        // ignore
                    } finally {
        
                        lock1.unlock();
                        countDownLatch.countDown();
                    }
                }
            };
            // 任务2：先获取lock2，然后睡眠2秒，再获取lock1
            Runnable runnable2 = new Runnable() {
        
                @Override
                public void run() {
        
                    lock2.lock();
                    try {
        
                        Thread.sleep(2000);
                        lock1.lock();
                        try {
        
                            System.out.println("先获取锁2再获取锁1");
                        } finally {
        
                            lock1.unlock();
                        }
                    } catch (InterruptedException e) {
        
                        // ignore
                    } finally {
        
                        lock2.unlock();
                        countDownLatch.countDown();
                    }
                }
            };
    
            // 创建线程1，并启动，此时线程1会拿到lock1
            Thread thread1 = new Thread(runnable1, "线程1");
            thread1.start();
    
            // 放弃时间片，确保线程1拿到lock1
            for (int k = 0; k < 100; k++) {
        
                Thread.yield();
            }
    
            // 创建线程2，并启动，此时线程2会拿到lock2
            Thread thread2 = new Thread(runnable2, "线程2");
            thread2.start();
    
            // 主线程阻塞在CountDownLatch上
            countDownLatch.await();
        }
    
    }

在上述示例中，锁**lock1**和**lock2**同时只能被一个线程占有，满足`互斥`条件。线程1占有**lock1**并等待**lock2**时并没有释放**lock1**（线程2同理），满足`占有且等待`条件。线程1和线程2均不能强行抢占彼此持有的锁资源，满足`不可抢占`条件。线程1在等待线程2占有的**lock2**，线程2在等待线程1占有的**lock1**，满足`循环等待`条件。因此，上述示例会形成死锁。

运行测试程序，无任何打印，这是因为发生了死锁，此时使用`jstack`导出线程堆栈信息，可以发现死锁的相关信息，如下所示。

![在这里插入图片描述][9fe391ff11ae4d529c73ed0b1975c26b.jpeg_pic_center]

### 总结 ###

产生死锁的条件如下所示。

死锁的解决：**破环产生死锁的条件中的任意一个**。

**注意**：`互斥`不可破坏。

[9fe391ff11ae4d529c73ed0b1975c26b.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/573d6e6fcadd497888d1e87068be365e.jpeg