精华内容
下载资源
问答
  • 如何解决死锁

    2019-04-22 19:59:13
    最近参加了一些公司的校招笔试,经常遇见:如何解决死锁的问题。复习之后,决定写篇博客,方便以后复习与回顾。 死锁的定义 多个进程在执行过程中,因争夺同类资源且资源分配不当而造成的一种互相等待的现象,若无...

    面试中经常遇见:如何解决死锁的问题。复习之后,决定写篇博客,方便以后复习与回顾。

    死锁的定义

    多个进程在执行过程中,因争夺同类资源且资源分配不当而造成的一种互相等待的现象,若无外力作用,它们都将永远无法继续执行,这种状态称为死锁,这些处于等待状态的进程称为死锁进程。

    死锁的四个必要条件

    1. 互斥条件:
      资源是独占的且排他使用,进程互斥使用资源,即任意时刻一个资源只能给一个进程使用,其他进程若申请一个资源,而该资源被另一进程占有时,则申请者等待直到资源被占有者释放。
    2. 不可剥夺条件:
      进程所获得的资源在未使用完毕之前,不被其他进程强行剥夺,而只能由获得该资源的进程资源释放。
    3. 占有且等待条件:
      进程每次申请它所需要的一部分资源,在申请新的资源的同时,继续占用已分配到的资源。
    4. 循环等待条件:
      在发生死锁时必然存在一个进程等待队列{P1,P2,…,Pn},其中P1等待P2占有的资源,P2等待P3占有的资源,…,Pn等待P1占有的资源,形成一个进程等待环路,环路中每一个进程所占有的资源同时被另一个申请,也就是前一个进程占有后一个进程所申请地资源。

    这四个条件是死锁的必要条件,只要系统发生死锁,这些条件必然成立,而只要上述条件之一不满足,就不会发生死锁。

    解决死锁的策略

    • 死锁预防
    • 死锁避免
    • 死锁检测
    • 死锁解除
    1. 死锁预防: 破坏导致死锁必要条件中的任意一个就可以预防死锁。
      例如:
      (1)破坏占有且等待条件: 一次性申请所有资源,之后不再申请资源,如果不满足资源条件则得不到资源分配。
      (2)破坏不可剥夺条件: 当一个进程获得某个不可剥夺的资源时,提出新的资源申请,若不满足,则释放所有资源。
      (3)破坏循环等待条件: 对资源进行排号,按照序号递增的顺序对资源进行申请。若获得高序号的资源想要申请低序号的资源,需要先释放高序号的资源。
    2. 死锁避免: 进程在每次申请资源时判断这些操作是否安全。
      例如:
      使用银行家算法:指在分配资源之前先看清楚,资源分配后是否会导致系统死锁。如果会死锁,则不分配,否则就分配。
    3. 死锁检测: 判断系统是否属于死锁的状态,如果是,则执行死锁解除策略。
    4. 死锁解除: 将某进程所占资源进行强制回收,然后分配给其他进程。(与死锁检测结合使用的)

    笔试总结:学技术最重要的还是扎实基础,希望自己能在点滴积累中有所提升!
    文章中不足与不对之处还需大佬们多多指点~

    展开全文
  • 文章目录死锁和如何解决死锁思路死锁形成死锁的四个必要条件处理死锁的思路预防死锁的方法死锁的解除办法 死锁和如何解决死锁思路 死锁 进程A占有a资源 希望获得进程B占有的b资源,进程B希望获得a资源,A,B对占有...

    死锁和如何解决死锁思路

    死锁

    进程A占有a资源 希望获得进程B占有的b资源,进程B希望获得a资源,A,B对占有资源不会释放,也不能抢占 造成一直等待的情况

    形成死锁的四个必要条件

    • 互斥条件: 一个资源每次只能被一个进程使用
    • 请求与保持条件: 一个进程因请求资源而阻塞时,对已获得的资源保持不放
    • 不剥夺条件: 进程已获得的资源,在未使用完之前,不能强行剥夺
    • 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系

    处理死锁的思路

    • 预防死锁
      • 破坏上面提及的四个条件中的一个或多个,互斥条件,允许一个资源被同时访问(不太好) 请求与保持条件、不剥夺条件 出现优先级关系,会导致某些级别低的进程长时间无法获得资源
    • 避免死锁
      • 在资源动态分配的过程中,用某种方式防止系统进入不安全的状态
    • 检测死锁
      • 允许死锁发生,检测是否有死锁出现,然后解开
    • 解除死锁
      • 发送死锁后,撤销进程,回收资源,分配给正在阻塞状态的进程

    预防死锁的方法

    • 破坏请求和保持条件
      • 一次性的申请所有资源,之后不再申请资源,如果不满足资源条件则得不到资源分配
      • 只获得初期资源运行,之后将运行完的资源释放,请求新的资源
    • 破坏不可抢占条件
      • 当一个进程获得某种不可抢占的资源,提出新的资源申请,若不能满足,则释放所有资源,以后需要,再次重新申请
    • 破坏循环等待条件
      • 对资源进行排号,按照序号递增的顺序请求资源,若进程获得序号高的资源想要获取序号低的资源,就需要先释放序号高的资源 (保证稀有资源都是后面获取的?)

    死锁的解除办法

    • 抢占资源,从一个或多个进程中抢占足够数量的资源,分配给死锁进程,以解除死锁状态
    • 终止(撤销)进程: 将一个或多个死锁进程终止(撤销),直到打破循环环路,使系统从死锁状态解脱
    展开全文
  • 为什么产生死锁和如何解决死锁 过多的同步可能造成相互不释放资源,而导致的相互等待 同步中持有多个对象的锁 ‘解决方案是不要在同一个代码块中,同时持有多个对象的锁 package cn.com.state; public class ...

    为什么产生死锁和如何解决死锁
    过多的同步可能造成相互不释放资源,而导致的相互等待
    同步中持有多个对象的锁
    ‘解决方案是不要在同一个代码块中,同时持有多个对象的锁

    package cn.com.state;
    
    public class TestDeadLock {
        public static void main(String[] args) {
            //测试死锁 过多的同步可能造成相互不释放资源,从而相互等待
            //一般发生于同步中持有多个对象的锁
    
            //避免: 不要再同一个代码块中,同时持有多个对象的锁
            Makeup m1 = new Makeup(1,"小红");
            Makeup m2 = new Makeup(0,"小亮");
            m1.start();
            m2.start();
        }
    }
    class Lipstick {
    
    }
    class Mirror {
    
    }
    class Makeup extends Thread {
        static Lipstick lipstick = new Lipstick();
        static Mirror mirror = new Mirror();
    
        //选择
        int choice;
        String name;
        public Makeup(int choice,String name) {
            this.choice = choice;
            this.name = name;
        }
        @Override
        public void run() {
            makeup();
        }
        //相互持有对方的锁  造成死锁
        private void makeup() {
            if (choice ==0) {
                synchronized(lipstick) { //获得口红的锁
                    System.out.println(this.name+"涂口红");
                    //1秒后想拥有镜子的锁
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    //                synchronized(mirror) {
    //                    System.out.println(this.name+"照镜子");
    //                }
                }
                synchronized(mirror) {
                    System.out.println(this.name+"照镜子");
                }
            }else {
                synchronized(mirror) { //获得镜子的锁
                    System.out.println(this.name+"照镜子");
                    //两秒后想拥有口红的锁
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    //                synchronized(lipstick) {
    //                    System.out.println(this.name+"涂口红");
    //                }
                }
                synchronized(lipstick) {
                    System.out.println(this.name+"涂口红");
                }
            }
        }
    }
    
    展开全文
  • 死锁以及如何解决死锁

    千次阅读 2019-03-10 21:42:02
    包括我之前总结的cpu100%如何解决也有。 死锁4大要素:互斥,持有并请求,不可剥夺,持续等待 那么如何避免死锁?破坏其中一个条件 说是这么说,代码撸起来。写一个死锁: public class TheBackLock { public...

    转自https://www.cnblogs.com/aflyun/p/9194104.html,真的很详细。包括我之前总结的cpu100%如何解决也有。

    死锁4大要素:互斥,持有并请求,不可剥夺,持续等待

    那么如何避免死锁?破坏其中一个条件

    说是这么说,代码撸起来。写一个死锁:

    public class TheBackLock {
    
        public static String object1 = "obj1";
        public static String object2 = "obj2";
    
        public static void main(String[] args) {
            Thread thread = new Thread(new MyThread(false));
            Thread thread1 = new Thread(new MyThread(true));
            thread.start();
            thread1.start();
        }
    
    }
    
    class MyThread implements Runnable {
    
        private boolean flag;
    
        public MyThread(boolean flag) {
            this.flag = flag;
        }
    
        @Override
        public void run() {
            if (flag) {
                try {
                    while (true) {
                        synchronized (TheBackLock.object1) {
                            System.out.println(Thread.currentThread().getName() + "lock object1");
                            Thread.sleep(3000);
                            synchronized (TheBackLock.object2) {
                                System.out.println(Thread.currentThread().getName() + "lock object2");
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else {
                try {
                    while (true) {
                        synchronized (TheBackLock.object2) {
                            System.out.println(Thread.currentThread().getName() + "lock object2");
                            Thread.sleep(3000);
                            synchronized (TheBackLock.object1) {
                                System.out.println(Thread.currentThread().getName() + "lock object1");
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
        }
    }
    

    这例子分析下如何死锁了,第一个互斥条件,有两个线程,我们命名为a,b吧。a获取object1锁,synchronized是由jvm进行管理的锁,Thread.sleep(3000)是为了让b有获取object2锁的充足时间。那么3秒过后,a去尝试获取object2锁的时候,这时就互斥了。第二持有并请求,a有了object1锁,再请求object2锁的时候才会死锁。第三不可剥夺 ,synchronized不像Lock类,扩展性强。第四持续等待看到while(true)了没有

     

    如何解决死锁

    1.调用jps -l

    输出完全的包名,应用主类名,jar的完全路径名 

    jstack -l pid

    查看堆栈信息

    jmap也可以dump下来堆栈的信息查看

     

    deadlock有没有

     

    2.使用jdk->bin下面Visual VM

    监控很到位,虽然我不是很会用

    3.cpu100%我之前博客说过

    https://blog.csdn.net/weixin_38336658/article/details/81437022

     

    总结:不外乎找到占用的pid,转tid,jstack pid,或者jmap  dump出来,查看对应哪里报错

     

     

     

     

    展开全文
  • 什么是死锁和如何解决死锁

    万次阅读 多人点赞 2016-11-27 21:14:18
    死锁(Deadlock)的形成 竞争不可抢占资源引起死锁 竞争可消耗资源引起死锁 进程推进顺序不当引起死锁 产生死锁的必要条件 互斥条件 请求和保持条件 不可抢占条件 循环等待条件 处理死锁的思路。 预防死锁...
  • Redisson是如何解决死锁问题的? 普通利用Redis实现分布式锁的时候,我们可能会为某个锁指定某个key,当线程获取锁并执行完业务逻辑代码的时候,将该锁对应的key删除掉来释放锁。 lock->set(key),成功->...
  • 使用redis做分布式锁时大家可能都知道使用setnx容易发生死锁情况,大多数都会推荐使用redission来实现,那么redission是如何解决死锁问题的呢? 有关Redisson作为实现分布式锁,总的分3大模块来讲。 1. `1、...
  • 死锁:是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象, 若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁。 1、普通死锁 1.1 死锁...
  • 死锁: 在两个或两个以上线程运行中,因为资源抢占而造成线程一直等待的问题。 写个代码,更清晰的表示一下: public class ThreadDemo01 { public static void main(String[] args) { Object lockA = new Object...
  • 如何解决死锁? 写一段死锁的代码吧! 什么是死锁? 死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁...
  • 什么是死锁? 锁,顾名思义,含义真的就是我们平常每天看到的那个锁,锁门的锁,如果门锁着,那就进不去了,那就只能在门外等着。 软件中的锁,意义和这个类似,也是为了阻止非授权用户能够进入某些代码的执行,...
  • 造成死锁的原因: 1.在一个代码块中同时获得多个锁,导致多个线程同时执行代码时,获取锁之间相互依赖,从而导致锁“抱死”。例如,t1线程首先获得A锁,再获得B锁,t2线程先获得B锁,再获得A锁,当t1获得A锁的同时...
  • 死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为...
  • 死锁产生的条件及如何解决死锁

    千次阅读 2020-03-04 20:39:11
    文章目录死锁的概念及产生的条件 死锁的概念及产生的条件 1、死锁的概念:死锁是指两个或两个以上的进程或线程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法向前...
  • 如何解决死锁问题

    2005-02-16 13:47:00
    如何解决死锁问题 主要介绍如何得到死锁的住处,以及避免死锁产生的常用方法.主要包括: 环境准备 查看死锁信息 避免死锁的几个常用方法 环境准备: create table David01...
  • ## 什么是死锁死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相...
  • 死锁的条件互斥条件(Mutual exclusion):资源不能被共享,只能由一个进程使用。请求与保持条件(Hold and wait):已经得到资源的进程可以再次申请新的资源。非剥夺条件(No pre-emption):已经分配的资源不能从...
  • **死锁是指两个或两个以上进程在执行过程中,因争夺资源而造成的下相互等待的现象。死锁发生的四个必要条件如下: 互斥条件:进程对所分配到的资源不允许其他进程访问,若其他进程访问该资源,只能等待,直至占有该...
  • 死锁是指两个或两个以上的进程,由于争夺资源而产生的相互等待的状态。 死锁发生的四个必要条件包括:互斥、不可剥夺、请求和保持、循环等待。 互斥指的是多个进程不能同时获得某项系统资源。 不可剥夺指的是一个...
  • 死锁产生的条件 产生死锁必须同时满足以下四个条件,只要其中任一条件不成立,死锁就不会发生。 ①互斥条件(Mutual exclusion):资源不能被共享,只能由一个进程使用。 ②请求与保持条件(Hold and wait):进程已获得...
  • 缓存-分布式锁-Redisson-lock看门狗原理-redisson如何解决死锁 1.测试lock第二种用法 @ResponseBody @GetMapping("/hello") public String hello(){ //1.获取一把锁,只要锁的名字一样,就是同一把锁 RLock lock...
  • 实现一个最简单的死锁(Java版) /** * @author wall * @date 2019/7/29 16:42 * @description 实现一个死锁:A线程获取B线程占有的锁,B线程获取A线程占有的锁 */ public class DeadLock { //定义两把锁 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,413
精华内容 565
关键字:

如何解决死锁