【Java EE】-多线程编程(四) 死锁

作者：学Java的冬瓜
博客主页：☀冬瓜的主页
专栏：【JavaEE】
分享：2023.3.31号骑行的照片再发一次(狗头)。
主要内容：什么是死锁？不可重入可重入、死锁的三个典型情况：1、一个线程一把锁，连续加锁两次 2、两个线程两把锁，同时获取对方的锁 3、N个线程M把锁，哲学家就餐问题。死锁的四个必要条件，如何破除死锁。

一、什么是死锁？

• 死锁是指两个或者两个以上的进程(线程)在执行过程中，因争夺资源而造成一种互相等待的现象。这些进程(线程)在等待彼此释放已经占用的资源，它们都无法继续执行下去。死锁的产生可能使系统进入假死状态，无法响应任何输入。

二、不可重入(Java中可重入)

• 一个线程在执行一个临界区时，需要访问一个共享资源，例如一个共享变量或函数。但是，如果在该临界区内部再次请求访问该共享资源，则可能会导致死锁。因为此时该共享资源已经被该线程占用，无法再次获得访问权，而其他线程也无法访问该资源，从而产生死锁。

       如下操作，锁对象都是this，注意：修饰方法就是给当前的实例对象加锁(也就是this对象)
执行进入add方法时，这个线程给this第一次加锁，可以加锁成功，然后遇到代码块，尝试再次加锁。但是呢，在this看来，自己已经被第一个线程加过锁了，所以此时尝试加锁的线程就会阻塞等待，但其实两次加锁的线程是同一个，这就是不可重入导致死锁。

synchronized public void add() {
    synchronized(this) {
    	count++;
    }
}

       如果两次加锁的线程不是同一个，那不可重入，只是让后一个加锁的线程阻塞等待，不会死锁。但是同一个线程对同一个对象加两次锁，就会死锁。为了防止这种死锁，在java中，synchronized、ReentrantLock加锁时，我们给线程开了个后门，让线程可重入。就是说：同一个线程给同一个对象加锁时，可以反复加锁。(但是在c++，python，操作系统原生的锁是不可重入的)。
       那么怎么实现呢？我可以在这个锁对象上记录下来，当前的锁是属于哪个线程的，如果再次加锁的线程是记录在所对象中的线程，就直接放过去，不阻塞，(两次加锁时，锁对象是同一个)。如果不是同一个线程，那就让后加锁的线程阻塞等待。

三、死锁的3个典型情况

1、一个线程一把锁，连续加锁两次

       在上面已经说过，在java中，synchronized河ReentrantLock都是可重入的，所以一个线程一把锁，连续加锁两次，在java中是不会死锁的，但是其它语言中就不一样了比如Python，C++，操作系统原生的锁都是不可重入的，都会造成死锁。

synchronized public void add() {
    synchronized(this) {
    	count++;
    }
}

2、两个线程两把锁，同时获取对方的锁

       在下面代码中给了一个例子：线程一有钱，要拿去换货，而线程2有货，拿货去换钱。但是在交换时，线程1不肯先把钱给线程2，而线程二也不肯先把货交给线程一，这就让两个线程无法继续往下执行，导致死锁。

// 死锁演示：开始时，线程1拿到钱，线程2拿到货，但是交换时谁都不肯先给对方，所以就死锁了
public class Main {
    public static void main(String[] args) {
        Object qian = new Object();
        Object huo = new Object();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (qian){
                    // sleep为了确保线程2先拿到货，而不是由线程1拿到钱和货
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }

                    synchronized (huo){
                        System.out.println("线程1拿到了钱和货");
                    }
                }
            }
        });

        Thread t2 = new Thread(){
            @Override
            public void run(){
                synchronized (huo){
                    // sleep为了确保线程1先拿到钱,而不是由线程2先拿到货和钱
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }

                    synchronized (qian){
                        System.out.println("线程2拿到了货和钱");
                    }
                }
            }
        };

        t1.start();
        t2.start();
        try {
        	// 确保t1和t2在main之前执行
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

3、N个线程M把锁

典型例子：哲学家就餐问题
问题描述：
五个哲学家围坐在一张圆桌前，每个哲学家面前都有一碗米饭和一只筷子。哲学家只会做两件事情：思考和就餐。当哲学家想要就餐时，他必须同时拿到他左右两边的筷子。如果他只拿到了一只筷子，他就不能就餐。当哲学家就餐时，他会占用两只筷子，其他哲学家就不能就餐了。每个哲学家思考的时间是随机的，就餐的时间也是随机的。当所有哲学家都就餐完毕后，程序结束。

实现方式：
为了避免死锁问题，可以让其中一个哲学家先拿右边的筷子，而其他哲学家则先拿左边的筷子，这样就可以避免所有哲学家同时拿起左边的筷子，而导致死锁问题的发生。其实也就是给筷子编号，每个哲学家只能先拿小的筷子，如果不理解可以看以下图示：

四、死锁的4个必要条件

1、互斥

线程1拿到锁，线程2就得阻塞等待。

2、不可抢占

线程1拿到锁，线程2就得阻塞等待，等线程1释放锁后，线程2才能尝试获取锁。

3、请求和保持

线程1拿到锁 A后，再尝试获取 B，A这把锁还是保持的，不会因为要获取 B就把 A释放了。

4、循环等待

线程1有锁 A，尝试获取锁 B。线程2有锁 B，尝试获取锁 A。即线程1和线程2都在等待对方释放拥有的锁，然后尝试自己获取到。

五、如何破除死锁

1、破除情况1

在Java中，synchronized和ReentrantLock都是可重入锁，同一个线程对同一个对象加两次锁，不会死锁。所以，不需要考虑。至于其它语言，以后学到了再说。

2、破除情况2、3

方法：给对象编号，按照顺序，加锁和释放锁。
       比如情况2中，给钱编号为1，给货编号为2，按编号加锁。两个线程获取时，只能都先获取钱的锁，当前程1获取到钱的锁时，线程2只能等待线程1释放钱的锁，而线程1可以获取到货的锁了，等它都获取到锁后执行完后，把货和钱的锁都释放了。那此时线程2就可以尝试获取钱的锁，获取到后，再去尝试获取货的锁。
       在代码上来看的话，两个线程都应该是外面是给qian加锁，里面是给huo加锁，如下示例。

		Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (qian){
                    // sleep为了确保线程2先拿到货，而不是由线程1拿到钱和货
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }

                    synchronized (huo){
                        System.out.println("线程1拿到了钱和货");
                    }
                }
            }
        });

       在情况3中，我们可以给每个筷子编号，每个哲学家只能先拿编号小的筷子，那这样的话，即使是极端情况下也不会出现死锁，具体情况见下图。