专栏原创出处：github-源笔记文件 (opens new window) ，github-源码 (opens new window)，欢迎 Star，转载请附上原文出处链接和本声明。

Java 并发编程专栏系列笔记，系统性学习可访问个人复盘笔记-技术博客 Java 并发编程 (opens new window)

• 什么是死锁
• 什么时候会死锁
• 死锁代码模拟
  • synchronized 关键字模拟死锁场景
  • ReentrantLock 模拟死锁场景
• 如何避免死锁

什么是死锁

两个或多个线程互相持有对方需要的锁而导致这些线程全部处于永久阻塞状态。
如：线程 A 持有对象 1 的锁，等待对象 2 的锁；线程 B 持有对象 2 的锁，等待对象 1 的锁。

什么时候会死锁

出现死锁必须具备以下几点:

1. 要有两个或两个以上的线程
2. 至少有两个共享资源的锁
3. 至少存在两个线程各自拥有一个锁
4. 现在这两个线程在等待获取彼此的锁，这就出现死锁了

死锁代码模拟

模拟逻辑说明：
两个线程 thread1、thread2 运行过程中需要在 lock1、lock2 两个共享资源上加锁。

• thread1 加锁顺序为 lock1->lock2
• thread1 加锁顺序为 lock2->lock1

synchronized 关键字模拟死锁场景

// synchronized 关键字出现死锁的场景
class SynchronizedDeadLockExample {

    public static void main(String[] args) {
        final Object lock1 = new Object();
        final Object lock2 = new Object();

        final Thread thread1 = new Thread(() -> {
            synchronized (lock1) {              // 对 lock1 加锁
                System.out.println("lock1");
                try {
                    sleep(200);
                } catch (InterruptedException e) {
                }
                synchronized (lock2) {          // 对 lock2 加锁
                    System.out.println("lock1->lock2");
                }
            }
        });
        thread1.setName("Thread-DeadLockExample-1");


        final Thread thread2 = new Thread(() -> {
            synchronized (lock2) {            // 对 lock2 加锁
                System.out.println("lock2");
                try {
                    sleep(200);
                } catch (InterruptedException e) {
                }
                synchronized (lock1) {        // 对 lock1 加锁
                    System.out.println("lock2->lock1");
                }
            }
        });
        thread2.setName("Thread-DeadLockExample-2");

        thread1.start();
        thread2.start();
    }
}

ReentrantLock 模拟死锁场景

// 注意：lock 加锁解锁代码为了方便演示移除 try {} finally {}，实际开发不推荐这种写法
class LockDeadLockExample {

    public static void main(String[] args) {

        final ReentrantLock lock1 = new ReentrantLock();
        final ReentrantLock lock2 = new ReentrantLock();

        final Thread thread1 = new Thread(() -> {
            lock1.lock();
            System.out.println("lock1");
            try {
                sleep(200);
            } catch (InterruptedException e) {
            }

            lock2.lock();
            System.out.println("lock1->lock2");
            lock2.unlock();

            lock1.unlock();
        });
        thread1.setName("Thread-DeadLockExample-1");

        final Thread thread2 = new Thread(() -> {
            lock2.lock();
            System.out.println("lock2");
            try {
                sleep(200);
            } catch (InterruptedException e) {
            }

            lock1.lock();
            System.out.println("lock2->lock1");
            lock1.unlock();

            lock2.unlock();
        });
        thread2.setName("Thread-DeadLockExample-2");

        thread1.start();
        thread2.start();
    }
}

如何避免死锁

• 加锁顺序：保证获取锁的顺序一致，例如示例中永远以 lock1->lock2 顺序加锁解锁
• 加锁时限：如果一个线程没有在指定的时间期限内获取到锁，则结束当前线程并释放掉已获得的锁
• 死锁检测：利用开源工具扫描检测