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

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

【Java EE】-多线程编程(四) 死锁_第1张图片

文章目录

  • 一、什么是死锁?
  • 二、不可重入(Java中可重入)
  • 三、死锁的3个典型情况
    • 1、一个线程一把锁,连续加锁两次
    • 2、两个线程两把锁,同时获取对方的锁
    • 3、N个线程M把锁
  • 四、死锁的4个必要条件
    • 1、互斥
    • 2、不可抢占
    • 3、请求和保持
    • 4、循环等待
  • 五、如何破除死锁
    • 1、破除情况1
    • 2、破除情况2、3

一、什么是死锁?

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

二、不可重入(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把锁

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

实现方式:
为了避免死锁问题,可以让其中一个哲学家先拿右边的筷子,而其他哲学家则先拿左边的筷子,这样就可以避免所有哲学家同时拿起左边的筷子,而导致死锁问题的发生。其实也就是给筷子编号,每个哲学家只能先拿小的筷子,如果不理解可以看以下图示:
【Java EE】-多线程编程(四) 死锁_第2张图片

四、死锁的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中,我们可以给每个筷子编号,每个哲学家只能先拿编号小的筷子,那这样的话,即使是极端情况下也不会出现死锁,具体情况见下图。
【Java EE】-多线程编程(四) 死锁_第3张图片

你可能感兴趣的:(JAVAEE,java-ee,java,jvm)