首页 > 基础资料 博客日记

Java中的死锁及其解决方案

2023-07-24 10:32:55基础资料围观240

本篇文章分享Java中的死锁及其解决方案,对你有帮助的话记得收藏一下,看Java资料网收获更多编程知识

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();
    }



}


文章来源:https://blog.csdn.net/weixin_45936627/article/details/129291519
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若内容造成侵权/违法违规/事实不符,请联系邮箱:jacktools123@163.com进行投诉反馈,一经查实,立即删除!

标签:

相关文章

本站推荐

标签云