Java中的死锁及其解决方案

最新推荐文章于 2024-06-07 12:56:21 发布

沐白

最新推荐文章于 2024-06-07 12:56:21 发布

阅读量6.6k

点赞数 26

文章标签： java Powered by 金山文档

本文链接：https://blog.csdn.net/weixin_45936627/article/details/129291519

版权

Java中的死锁及其解决方案

在Java中，锁是很常见的一个工具，常见的用法就是在高并发场景下保证线程安全，但是使用不当也会造成死锁，给我们带来一些不必要的麻烦，本文分析死锁及其产生原因，并作出相应的解决方案。

死锁产生的四个必要条件

1）互斥条件：进程对所分配到的资源进行排他性控制，即在一段时间内某资源仅为一个进程所占有。此时若有其他进程请求该资源，则请求进程只能等待。

2）请求和保持条件：进程已经获得了至少一个资源，但又对其他资源发出请求，而该资源已被其他进程占有，此时该进程的请求被阻塞，但又对自己获得的资源保持不放。

3）不可剥夺条件：进程已获得的资源在未使用完毕之前，不可被其他进程强行剥夺，只能由自己释放。

4）环路等待条件：存在一种进程资源的循环等待链，链中每一个进程已获得的资源同时被链中下一个进程所请求。

生活示例

死锁就好比两个人去过独木桥，小庞从桥左边出发，小贾从桥右边出发，然后到了桥中间，小庞要去右边，小贾要去左边，但两者都互不想让，最终只能在桥中间站着，造成死循环，谁也过不了河的结果。

对象A先持有锁1，然后对象B持有锁2，此时对象A要去获取锁2，但是锁2此时在对象B手里，对象B要去获取锁1，锁1在对象A手里，对象A，B互不相让，最终导致死链现象，出现死锁。

死锁代码

方式1，继承Runnable接口实现

package com.wwy.lock;

import java.util.concurrent.TimeUnit;

public class DieLock {
    public static void main(String[] args) {


         Object A = new Object();

         Object B = new Object();

         //线程1
        /**
         * ()->{} 此为jdk8新增的新特性  但要求目标接口只有一个抽象方法，而Runnable恰好符合此条件
         */
        Thread thread1 = new Thread(()->{
            synchronized (A){
                System.out.println("线程1此时获取锁A");
                try {
                    /**
                     * TimeUnit是一个时间工具类，更好的帮助我们定义休眠时间
                     *TimeUnit.DAYS //天
                     * TimeUnit.HOURS //小时
                     * TimeUnit.MINUTES //分钟
                     * TimeUnit.SECONDS //秒
                     * TimeUnit.MILLISECONDS //毫秒
                     * TimeUnit.NANOSECONDS //毫微秒
                     * TimeUnit.MICROSECONDS //微秒
                     */
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //对象A苏醒之后再去尝试获取锁2
                synchronized (B){
                    System.out.println("线程1此时获取锁B");
                }
            }
        });

        thread1.start();
        //线程2
        Thread thread2 = new Thread(()->{
            synchronized (B){
                System.out.println("线程2此时获取锁B");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //对象A苏醒之后再去尝试获取锁2
                synchronized (A){
                    System.out.println("线程2此时获取锁A");
                }
            }
        });

        thread2.start();
    }

}

方式2，继承Thread类（不推荐使用）

package com.wwy.lock;

import java.util.concurrent.TimeUnit;

public class ThreadA extends Thread {
    private Object A ;
    private Object B ;

    public Object getA() {
        return A;
    }

    public void setA(Object a) {
        A = a;
    }

    public Object getB() {
        return B;
    }

    public void setB(Object b) {
        B = b;
    }

    @Override
    public void run() {
        synchronized (A){
            System.out.println("线程1此时获取锁A");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (B){
                System.out.println("线程1此时获取锁B");
            }
        }
    }
}

package com.wwy.lock;

import java.util.concurrent.TimeUnit;

public class ThreadB extends Thread {

   private Object A ;
   private Object B ;

    public Object getA() {
        return A;
    }

    public void setA(Object a) {
        A = a;
    }

    public Object getB() {
        return B;
    }

    public void setB(Object b) {
        B = b;
    }

    @Override
    public void run() {
        synchronized (B){
            System.out.println("线程2此时获取锁B");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (A){
                System.out.println("线程2此时获取锁A");
            }
        }
    }
}

package com.wwy.lock;

public class ThreadTest  {
    public static void main(String[] args) {

        Object A = new Object();
        Object B = new Object();
        ThreadA t1 = new ThreadA();
        ThreadB t2 = new ThreadB();
        t1.setA(A);
        t1.setB(B);
        t2.setA(A);
        t2.setB(B);
        t1.start();
        t2.start();
    }
}

检测死锁

正常情况下应该打印四句话的，可此时程序一直在运行状态并且只打印了两句话，说明出现死锁现象，验证方法，可以去到我们jdk目录下的bin目录中的一个可视化界面查看

可以看到此处确实出现死锁现象

死锁解决方案

预防死锁的方式就是打破四个必要条件中的任意一个即可。

1）打破互斥条件：在系统里取消互斥。若资源不被一个进程独占使用，那么死锁是肯定不会发生的。但一般来说在所列的四个条件中，“互斥”条件是无法破坏的。因此，在死锁预防里主要是破坏其他几个必要条件，而不去涉及破坏“互斥”条件。。

2）打破请求和保持条件：采用资源预先分配策略，即进程运行前申请全部资源，满足则运行，不然就等待。

每个进程提出新的资源申请前，必须先释放它先前所占有的资源。

3）打破不可剥夺条件：当进程占有某些资源后又进一步申请其他资源而无法满足，则该进程必须释放它原来占有的资源。

4）打破环路等待条件：实现资源有序分配策略，将系统的所有资源统一编号，所有进程只能采用按序号递增的形式申请资源。

方案一，改变两个线程获取锁的顺序

让线程1和线程2的获取锁的顺序都是先获取锁A在获取锁B

package com.wwy.lock;

import java.util.concurrent.TimeUnit;

public class DieLock {
    public static void main(String[] args) {


         Object A = new Object();

         Object B = new Object();

         //线程1
        /**
         * ()->{} 此为jdk8新增的新特性  但要求目标接口只有一个抽象方法，而Runnable恰好符合此条件
         */
        Thread thread1 = new Thread(()->{
            synchronized (A){
                System.out.println("线程1此时获取锁A");
                try {
                    /**
                     * TimeUnit是一个时间工具类，更好的帮助我们定义休眠时间
                     *TimeUnit.DAYS //天
                     * TimeUnit.HOURS //小时
                     * TimeUnit.MINUTES //分钟
                     * TimeUnit.SECONDS //秒
                     * TimeUnit.MILLISECONDS //毫秒
                     * TimeUnit.NANOSECONDS //毫微秒
                     * TimeUnit.MICROSECONDS //微秒
                     */
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //对象A苏醒之后再去尝试获取锁2
                synchronized (B){
                    System.out.println("线程1此时获取锁B");
                }
            }
        });

        thread1.start();
        //线程2
        Thread thread2 = new Thread(()->{
            synchronized (A){
                System.out.println("线程2此时获取锁A");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //对象A苏醒之后再去尝试获取锁2
                synchronized (B){
                    System.out.println("线程2此时获取锁B");
                }
            }
        });

        thread2.start();
    }



}

继承Runnable类也是如此解决，改变两个线程获取锁的顺序

方式二，使用ReentrantLock来解决

package com.wwy.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class DieLock {
    public static void main(String[] args) {


        ReentrantLock lockA = new ReentrantLock();

        ReentrantLock lockB = new ReentrantLock();

         //线程1
        /**
         * ()->{} 此为jdk8新增的新特性  但要求目标接口只有一个抽象方法，而Runnable恰好符合此条件
         */
        Thread thread1 = new Thread(()->{
            while(true) {
                if (lockA.tryLock()) {
                    System.out.println("线程1获取锁A");
                    try {
                        TimeUnit.SECONDS.sleep(1);
                        if (lockB.tryLock()) {
                            try {
                                System.out.println("线程1获取锁B");
                            } finally {
                                lockB.unlock();
                                System.out.println("线程1释放锁B");
                                break;
                            }

                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        /**
                         * ReentrantLock与synchronized不同的是需要手动释放掉以获取的锁
                         */
                        lockA.unlock();
                        System.out.println("线程1释放锁A");
                    }

                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        });

        thread1.start();
        //线程2
        Thread thread2 = new Thread(()->{
            /**
             * lock.lock()方法如果获取不到锁则禁用该线程，一直处于休眠状态，直至获取到锁为止
             */
            lockB.lock();
                System.out.println("线程2获取锁B");
                try {
                    TimeUnit.SECONDS.sleep(1);
                    lockA.lock();
                        try {
                            System.out.println("线程2获取锁A");
                        }finally {
                            lockA.unlock();
                            System.out.println("线程2释放锁A");
                        }

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                finally {
                    /**
                     * ReentrantLock与synchronized不同的是需要手动释放掉以获取的锁
                     */
                    lockB.unlock();
                    System.out.println("线程2释放锁B");
                }

        });

        thread2.start();
    }



}