【多线程】死锁 详解

一. 死锁是什么

死锁是这样一种情形：
多个线程同时被阻塞，因为每个进程都在等其他线程释放某些资源，同时又不释放自己占用的资源，从而导致系统陷入僵局。
由于线程被无限期地阻塞，因此程序不可能正常终止。
死锁是一种严重的 BUG!! 导致一个程序的线程 “卡死”, 无法正常工作!

二. 死锁的场景

1. 一个线程一把锁

一个线程对同一把锁上锁多次，如果该锁是 不可重入锁 就会死锁，否则是 可重入锁 就不会死锁。

代码举例：

        Object locker = new Object();
        // 对 locker 第一次加锁
        synchronized (locker) {
            // 对 locker 第二次加锁
            synchronized (locker) {
                // do something
            }
        }

因为 synchronized 是可重入锁， 所以它并不会导致死锁，但如果换成不可重入锁的话就会死锁。

2. 两个线程两把锁

A 持有 lock1, 等待 lock2, B 持有 lock2, 等待 lock1。
所以情况就是:
A 说：你先给我，我再给你。
B 说：我不，你先给我，我再给你。

比如：屋子的钥匙锁车里了，车钥匙锁屋里了。
代码举例：

class Test{
    public static void main(String[] args) throws InterruptedException {
        Object lock1 = new Object();
        Object lock2 = new Object();

        Thread threadA = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread A: Holding lock 1...");
                try { Thread.sleep(1000); } catch (InterruptedException e) {}
                System.out.println("Thread A: Waiting for lock 2...");
                synchronized (lock2) {
                    System.out.println("Thread A: Acquired lock 2.");
                }
            }
        });

        Thread threadB = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread B: Holding lock 2...");
                try { Thread.sleep(1000); } catch (InterruptedException e) {}
                System.out.println("Thread B: Waiting for lock 1...");
                synchronized (lock1) {
                    System.out.println("Thread B: Acquired lock 1.");
                }
            }
        });

        threadA.start();
        threadB.start();

    }
}

3. N 个线程 M 把锁

为了进一步阐述死锁的形成, 我们引用有名的 “哲学家就餐问题”.

• 有个桌子, 围着一圈 哲学家, 桌子中间放着一盘意大利面. 每个哲学家两两之间, 放着一根筷子.

• 每个哲学家只做两件事: 思考人生 或 吃面条. 思考人生时就会放下筷子. 吃面条就会拿起左右两边的筷子(先拿左边, 再拿右边).

• 如果哲学家发现筷子拿不起来了(被别人占用了), 就会阻塞等待.

• 假如出现极端情况：同一时刻, 五个 哲学家 同时拿起左手边的筷子, 然后再尝试拿右手的筷子, 就会发现右手的筷子都被占用了. 由于哲学家们互不相让, 这个时候就形成了 死锁.

三. 死锁产生的四个必要条件

• 互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用。
• 不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
• 请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的占有。
• 环路等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。

四. 如何避免死锁

当上述四个条件都成立的时候，便形成死锁。当然，死锁的情况下如果打破上述任何一个条件，便可让死锁消失。

其中最容易破坏的就是 “循环等待”.

最常用的一种死锁阻止技术就是锁排序:
假设有 N 个线程尝试获取 M 把锁, 就可以针对 M 把锁进行编号 (1, 2, 3…M).
N 个线程尝试获取锁的时候, 都按照固定的按编号由小到大顺序来获取锁. 这样就可以避免环路等待.

比如上面两个线程两把锁死锁的例子：

约定好先获取 lock1, 再获取 lock2 , 就不会环路等待.

class Test{
    public static void main(String[] args) throws InterruptedException {
        Object lock1 = new Object();
        Object lock2 = new Object();

        Thread threadA = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread A: Holding lock 1...");
                try { Thread.sleep(1000); } catch (InterruptedException e) {}
                System.out.println("Thread A: Waiting for lock 2...");
                synchronized (lock2) {
                    System.out.println("Thread A: Acquired lock 2.");
                }
            }
        });

        Thread threadB = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread B: Holding lock 1...");
                try { Thread.sleep(1000); } catch (InterruptedException e) {}
                System.out.println("Thread B: Waiting for lock 2...");
                synchronized (lock2) {
                    System.out.println("Thread B: Acquired lock 2.");
                }
            }
        });

        threadA.start();
        threadB.start();
    }
}

好啦！ 以上就是对 死锁 的讲解，希望能帮到你 ！
评论区欢迎指正 !