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

前言

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

正文

一. 死锁的产生

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

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导出线程堆栈信息，可以发现死锁的相关信息，如下所示。

总结

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

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

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

注意：互斥不可破坏。