精华内容
下载资源
问答
  • Java 死锁
    2019-06-02 15:22:59

    Java 死锁

    死锁代码Demo

    
        private void testDeadLock() {
            final Object lockA = new Object();
            final Object lockB = new Object();
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (lockA) {
                        try {
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        synchronized (lockB) {
                            Log.i("qinxue", "thread1 ");
                        }
                    }
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (lockB) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        synchronized (lockA) {
                            Log.i("qinxue", "thread2");
                        }
                    }
                }
            });
            thread1.start();
            thread2.start();
        }
    

    分析

    线程1:获取lockA,500ms后获取lockB才能继续执行打印"thread1"代码。
    线程2:获取lockB,1000ms后获取lockA才能继续执行打印"thread2"代码。
    死锁:

    线程1需要获取lockB
    线程2需要释放 lockB
    线程1需要释放LokA

    总结

    显示中的死锁多为一些异常情况没有释放锁(死循环),或者使用java多线程锁不当引起,应该避免手写多线程编程,多使用JDK并发包中的并发容器和工具类来解决并发问题,因为这些类都已经通过了充分的测试和优化。

    更多相关内容
  • 但在他们线程未执行完时,都不会释放AB资源,那么就形成了一种僵局,Thread1在等待Thead2施放B资源,Thread2在等待Thread1释放A资源,两个进程就形成了一种僵局,下面以Java代码实现为例说明: public class Dead...
  • 这些实验室之一尤其引起了我的关注:Java冠军Heinz Kabutz提出的“ HOL6500-查找和解决Java死锁 ”。 这是我在该主题上看到的最好的演示之一。 我建议您自己下载,运行和研究实验室。 本文将重温这个经典的线程...

    java 死锁 解决

    JavaOne年度会议的一大优点是主题专家介绍了几个技术和故障排除实验室。 这些实验室之一尤其引起了我的关注:Java冠军Heinz Kabutz提出的“ HOL6500-查找和解决Java死锁 ”。 这是我在该主题上看到的最好的演示之一。 我建议您自己下载,运行和研究实验室。

    本文将重温这个经典的线程问题,并总结提出的关键故障排除和解决方法。 我还将根据自己的多线程故障排除经验来扩展主题。

    Java死锁:这是什么?

    真正的Java死锁本质上可以描述为两个或多个线程永远被阻塞,互相等待的情况。 这种情况与其他更常见的“日常”线程问题模式(例如锁争用和线程争用,等待阻塞IO调用的线程等)截然不同。这种锁排序死锁情况可以如下所示:

    在上面的可视示例中,线程A和线程B尝试以不同顺序获取2个锁是致命的。 一旦线程达到死锁状态,它们将永远无法恢复,从而迫使您重新启动受影响的JVM进程。

    Heinz还描述了另一种死锁: 资源死锁 。 到目前为止,这是我在Java EE企业系统故障排除经验中最常见的线程问题模式。 资源死锁本质上是指一个或多个线程正在等待获取永远无法使用的资源(例如JDBC池耗尽)的情况。

    锁排序死锁

    您现在应该知道我是JVM线程转储分析的忠实拥护者 ; 对于参与Java / Java EE开发或生产支持的个人而言至关重要的技能。 好消息是,大多数JVM线程转储格式(HotSpot,IBM VM…)都可以很容易地对Java级别的死锁进行开箱即用的识别,因为它们包含本机死锁检测机制,该机制实际上将向您显示所涉及的线程。真正的Java级死锁场景以及执行堆栈跟踪。 可以通过您选择的工具(例如JVisualVM,jstack)或本地工具(例如,基于Unix的操作系统上的kill -3 <PID>)捕获JVM线程转储。 运行实验1后,在JVM Java级死锁检测部分下面找到:

    现在,这是容易的部分……根本原因分析工作的核心是首先了解为什么此类线程涉及死锁情况。 锁顺序死锁可能会从您的应用程序代码中触发,但是除非您参与高并发性编程,否则可能导致罪魁祸首的代码是您正在使用的第三方API或框架或实际的Java EE容器本身(如果适用)。

    现在让我们在下面回顾一下亨氏提出的锁排序死锁解决策略:

    #通过全局排序解决死锁(请参阅lab1解决方案)

    • 本质上涉及对锁的全局排序的定义,它将始终防止死锁(请参阅lab1解决方案)

    #TryLock的死锁解析(请参阅lab2解决方案)

    • 锁定第一把锁
    • 然后尝试锁定第二把锁
    • 如果您可以锁定它,那就很好了
    • 如果不能,请重试

    可以使用Java Lock&ReantrantLock来实现上述策略,这也使您可以灵活地设置等待超时,以防止在第一个锁获取时间太长的情况下导致线程不足。

    public interface Lock {
    
    void lock();
    
    void lockInterruptibly() throws InterruptedException;
    
    boolean tryLock();
    
    boolean tryLock(long timeout, TimeUnit unit)
    
    throws InterruptedException;
    
    void unlock();
    
    Condition newCondition();
    
    }

    如果查看JBoss AS7实现,您会注意到Lock&ReantrantLock在核心实现层中得到了广泛使用,例如:

    • 部署服务
    • EJB3实现(广泛使用)
    • 集群和会话管理
    • 内部缓存和数据结构(LRU,ConcurrentReferenceHashMap…)

    现在,按照亨氏的观点,死锁解决方案策略2可能非常有效,但也需要采取适当的措施,例如通过finally {}块释放所有持有的锁,否则您可以将死锁方案转换为活动锁

    资源僵局

    现在,让我们转到资源死锁场景。 我很高兴Heinz的实验室#3涵盖了这一点,因为根据我的经验,这是迄今为止您将看到的最常见的“死锁”场景,尤其是在开发和支持大型分布式Java EE生产系统时。

    现在,让我们弄清事实。

    • 资源死锁不是真正的Java级死锁
    • 如果您遇到这些类型的死锁,那么JVM线程转储将不会神奇。 这意味着您需要做更多工作来分析和理解此问题作为起点。
    • 当您刚开始学习如何读取线程转储时,线程转储分析可能会特别令人困惑,因为对于Java级死锁,线程通常会显示为RUNNING状态还是BLOCKED状态。 现在,重要的是要记住线程状态对于这种类型的问题不是那么重要,例如RUNNING state!= Healthy state。
    • 分析方法与Java级别的死锁非常不同。 您必须创建多个线程转储快照,并确定每个快照之间的线程问题/等待模式。 您将能够看到线程没有移动,例如等待从池中获取资源的线程以及已经获取并挂起资源的其他线程。
    • 线程转储分析不是这里唯一重要的数据点/事实。 您将需要收集其他事实,例如有关线程正在等待的资源,整体中间件或环境运行状况等的统计信息。所有这些事实的结合将使您能够得出根本原因以及解决策略的结论,或可能不涉及代码更改。

    我将以更多的线程转储问题模式与您联系,但是首先请确保您对JVM线程转储基本原理感到满意。

    结论

    我希望您像我一样有机会回顾,运行和享受亨氏演讲中的实验室。 并发编程和故障排除可能会非常具有挑战性,但是我仍然建议您花一些时间来理解其中的一些原则,因为我相信您会在不久的将来遇到某种情况,这将迫使您进行这种深入研究并掌握这些原则。技能。

    参考: Java EE支持模式和Java教程博客中的JCG合作伙伴 Pierre-Hugues Charbonneau提供的Java死锁故障排除和解决方法

    翻译自: https://www.javacodegeeks.com/2012/11/java-deadlock-troubleshooting-and-resolution.html

    java 死锁 解决

    展开全文
  • Java死锁

    2022-03-14 10:36:26
    死锁的定义是:两个或两个以上的线程或进程在执行过程中,由于竞争资源或者由于彼此通信而造成...死锁是在多线程编程中常常遇到的问题,现在用java编写一个简单的死锁程序。 程序在main()方法中启动2个线程,“线程-1

    死锁的定义是:两个或两个以上的线程或进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象。

    用白话讲就是:现在有线程1和线程2。线程1执行过程中,先锁定了对象a,然后需要再锁定b才能继续执行代码;而线程2正巧相反,先锁定了b,需要再锁定a才能继续执行代码。这时,两个线程都等着对方解锁,才能继续执行,于是两个线程就进入等待状态,最终不会有线程执行。这就变成了死锁。

    死锁是在多线程编程中常常遇到的问题,现在用java编写一个简单的死锁程序。

    程序在main()方法中启动2个线程,“线程-1”和“线程-2”。 线程-1 先拿到 lock1,再寻求拿到 lock2;线程-2 先拿到loc2,再需求拿到lock1,于是变成循环等待,造成死锁。

    1、死锁程序如下:

    /**
     * @author lwy
     * @create 2022-03-14 9:32
     */
    public class deadLockTest {
        public static void main(String[] args) {
            Object lock1 = new Object();
            Object lock2 = new Object();
            new Thread(() -> {
                String name = Thread.currentThread().getName();
                synchronized (lock1) {
                    System.out.println(name + "获得锁1,再去获取锁2");
                    try {
                        Thread.sleep(100);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    synchronized (lock2) {
                        System.out.println(name + "获得锁2");
                        System.out.println(name + ":Hello!");
                    }
                }
            }, "线程--1").start();
    
            new Thread(() -> {
                String name = Thread.currentThread().getName();
                synchronized (lock2) {
                    System.out.println(name + "获得锁2,再去获取锁1");
                    try {
                        Thread.sleep(100);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    synchronized (lock1) {
                        System.out.println(name + "获得锁1");
                        System.out.println(name + ":Hello!");
                    }
                }
            }, "线程--2").start();
        }
    }
    

    2、运行结果为:

     

    3、然后在终端输入:jps,查看该程序的进程号:

     

     4、在终端输入:jstack -F 25204查看结果

    5、或者在终端输入:jconsole,会弹出Java自带的监视和管理控制台

     6、接着点击“线程”

     7、再点击“检测死锁”

     8、点击“线程

     

    展开全文
  • java死锁简单案例

    2022-03-15 22:31:30
    1、线程死锁的概念: 我们都知道,线程在执行的过程中是占着CPU的资源的,当多个线程都需要一个被锁住的条件才能结束的时候,死锁就产生了! 还有一个经典的死锁现象: 经典的“哲学家就餐问题”,5个哲学家吃中餐,...

    每天一个小tip:map或者List等集合在循环下需要remove元素时,采用迭代器进行,因为需要进行checkForComodification,即对应一下modCount,实际每一次操作集合时,都会对modCount+1,当modCount大小不等于expectedModCount时,抛出ConcurrentModificationException(),回到正文~~~~

    1、线程死锁的概念:

    我们都知道,线程在执行的过程中是占着CPU的资源的,当多个线程都需要一个被锁住的条件才能结束的时候,死锁就产生了!

    还有一个经典的死锁现象:
    经典的“哲学家就餐问题”,5个哲学家吃中餐,坐在圆卓子旁。每人有5根筷子(不是5双),每两个人中间放一根,哲学家时而思考,时而进餐。每个人都需要一双筷子才能吃到东西,吃完后将筷子放回原处继续思考,如果每个人都立刻抓住自己左边的筷子,然后等待右边的筷子空出来,同时又不放下已经拿到的筷子,这样每个人都无法得到1双筷子,无法吃饭都会饿死,这种情况就会产生死锁:
    每个人都拥有其他人需要的资源,同时又等待其他人拥有的资源,并且每个人在获得所有需要的资源之前都不会放弃已经拥有的资源。当多个线程完成功能需要同时获取多个共享资源的时候可能会导致死锁。

    1:两个任务以相反的顺序申请两个锁,死锁就可能出现

    2:线程T1获得锁L1,线程T2获得锁L2,然后T1申请获得锁L2,同时T2申请获得锁L1,此时两个线程将要永久阻塞,死锁出现

    如果一个类可能发生死锁,那么并不意味着每次都会发生死锁,只是表示有可能。要避免程序中出现死锁。

    3:要避免死锁某个程序需要访问两个文件,当进程中的两个线程分别各锁住了一个文件,那它们都在等待对方解锁另一个文件,而这永远不会发生。
    总结:双方都在等待对方解锁,而自己也占有着对方想要的锁。死锁产生的必要条件:第一个就是线程之间必须互斥,一个资源只能一条线程用,比如其中一根筷子,a占有了,b就不能占有(但是b可能想占有,这就导致了死锁的其中一个必要条件),第二个就是线程因为占有着该资源而阻塞,因为想去获取别人的资源,但别人没有释放。第三个条件就是,你所获得的资源不想释放,那别人也得到不了。第四个条件就是循环等待,就比如刚刚的例子里面,形成了一个圆,收尾相互需要资源,形成一个环

    2、简单举例说明:

    // 互相想占用对方的资源,ab形成循环,互斥,不释放对方拿不到
    public static void main(String[] args) {
            // deadLock
            Object a = new Object();
            Object b = new Object();
            new Thread(() -> {
                synchronized (a) {
                    System.out.println("get a");
                    try {
                        Thread.sleep(Long.parseLong("1000"));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (b) {
                        System.out.println("want get b");
                    }
                }
            }, "a").start();
    
            new Thread(() -> {
                synchronized (b) {
                    System.out.println("get b");
                    try {
                        Thread.sleep(Long.parseLong("1000"));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (a) {
                        System.out.println("want get a");
                    }
                }
            }, "b").start();
    
    展开全文
  • java死锁排查

    2021-03-15 03:22:32
    废话不多说,直接看下面死锁代码,这是一个典型的死锁,线程1拿到A锁获取B锁,线程2拿到B锁获取A锁public class DeadLockTest{private static Object A = new Object(), B = new Object();public static void main...
  • 本篇文章主要介绍了java实现死锁的示例代码,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • java死锁代码

    2022-03-26 20:25:05
    * 死锁代码 */ public class DeadLock { public static void main(String[] args) { Object o1=new Object(); Object o2=new Object(); //t1和t2两个线程共享o1,o2; Thread t1=new MyThread1(o1,o2); ...
  • Java死锁如何避免? 造成死锁的⼏个原因: ⼀个资源每次只能被⼀个线程使⽤ ⼀个线程在阻塞等待某个资源时,不释放已占有资源 ⼀个线程已经获得的资源,在未使⽤完之前,不能被强⾏剥夺 若⼲线程形成头尾...
  • Java死锁的简单例子

    2021-04-17 10:08:04
    Java死锁的简单例子两个线程互相占有对方需要的资源而不释放,便形成了死锁。代码如下:Program.java/*** 程序类* @author michael**/public class Program implements Runnable {//两个静态的资源public static ...
  • Java死锁分析

    2021-05-13 17:58:14
    死锁是多进程环境下的一种假死现象,即产生死锁的进程都处于等待状态。只要满足了下面四个必要条件,就有可能产生死锁:互斥条件:进程对所分配到的资源不允许其他进程进行访问,若其他进程访问该资源,只能等待,...
  • 死锁是两个或多个线程永远被阻塞的编程情况,这种情况发生在至少两个线程和两个或更多资源的情况下。...Java死锁示例 package com.journaldev.threads; public class ThreadDeadlock { public static void main(Str...
  • java死锁

    千次阅读 2021-06-14 18:48:43
    public class Test { public static void main(String[] args) { Makeup g1=new Makeup(0,"灰姑凉"); Makeup g2=new Makeup(1,"白雪公主"); g1.start(); g2.start(); } } ...class Mak...
  • java死锁原因和解决

    2021-07-23 11:25:19
    死锁 简单点来说,两个或两个以上的线程情景下,线程A持有锁资源A,但是还想要资源B,于是请求B锁,线程B持有锁资源B,但是还想要资源A,于是请求A锁。两者互不释放锁,又想获得对方资源。 死锁条件 1、请求保持 2...
  • 四个Java死锁检测工具

    2022-03-25 17:07:42
    下面介绍一下如何排查Java中的死锁线程。 先来个死锁的例子: import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public ...
  • 如何避免Java死锁

    2021-09-19 18:50:12
    造成死锁的几个原因: 1.一个资源每次只能被一个线程调用; 2.一个线程在阻塞等待某个资源时,不释放已占用资源; 3.一个线程在获得资源,未使用完之前不能进行剥夺; 4.若干个线程头尾相连循环等待资源。 这...
  • Java死锁示例及检测

    2021-02-28 14:11:14
    死锁是指多个线程在等待不可能被释放的锁,导致程序无法继续运行,下面用一个例子来说明。线程A持有lock1,在等待lock2,线程B持有lock2,在等待lock1,这样就发生了死锁。首先看一个类DealThread,这个类含有互斥锁...
  • 进程死锁及解决办法一、要点提示(1) 掌握死锁的概念和产生死锁的根本原因。(2) 理解产生死锁的必要条件–以下四个条件同时具备:互斥条件、不可抢占条件、占有且申请条件、循环等待条件。(3) 记住解决死锁的一般方法...
  • 其中的一个实验室今年特别吸引了我的注意力:“ HOL6500-查找和解决Java死锁 ”,由Java冠军Heinz Kabutz提出 。 这是我在该主题上看到的最好的演示之一。 我建议您自己下载,运行和研究实验室。 本文将重温这个...
  • 1、互斥使用,即当资源被一个线程使用(占有)时,别的线程不能使用 2、不可抢占,资源请求者不能强制从资源占有者手中夺取资源,资源只能由资源占有者主动释放。 3、请求和保持,即当资源请求者在请求其他的资源的...
  • 相信程序员都会碰上这样的问题,Java死锁如何排查?又如何解决呢?那么,何为死锁呢?死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象。今天小编一次性来帮助大家...
  • Java 死锁以及如何避免?

    千次阅读 2021-03-04 07:10:15
    Java中产生死锁的原因以及如何避免:1. Java中导致死锁的原因Java死锁最简单的情况是,一个线程T1持有锁L1并且申请获得锁L2,而另一个线程T2持有锁L2并且申请获得锁L1,因为默认的锁申请操作都是阻塞的,所以线程...
  • 主要介绍了java中产生死锁的原因及如何避免,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • java死锁以及解决方案

    千次阅读 2021-05-25 16:38:20
    死锁是指两个或两个以上的进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力干涉那它们都将无法推进下去,如果系统资源充足,进程的资源请求都能够得到满足,死锁出现的可能性就很低,否则就会因...
  • 本文详细介绍了Java死锁的概念、原理、构建、排查、以及解决方法。
  • 首先使用jps查看Java进程编号,然后使用jstack查看进程信息,出现下述信息表示出现了死锁。jstack会在最后给出进程的分析信息,表示出现了死锁。 方法二:使用图形化工具jconsole.exe 第一步:打开jconsole,选择...
  • Java 中,死锁(Deadlock)情况是指:两个或两个以上的线程持有不同系统资源的锁,线程彼此都等待获取对方的锁来完成自己的任务,但是没有让出自己持有的锁,线程就会无休止等待下去。线程竞争的资源可以是:锁、...
  • Java死锁示例

    2020-07-23 09:33:08
    import java.util.concurrent.locks.ReentrantReadWriteLock; /** * 死锁 * * @Ahthor luohq * @Date 2020-07-23 */ public class Deadlock { public static void main(String[] args) { deadLock1(); //...
  • Java死锁产生的四个必要条件: 互斥使用,即当资源被一个线程使用(占有)时,别的线程不能使用。 不可抢占,资源请求者不能强制从资源占有者事中夺取资源,资源只能由资源占有者主动释放。 请求和保持,即当资源请求...
  • 今天小编就为大家分享一篇关于Java多线程产生死锁的必要条件,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 163,071
精华内容 65,228
关键字:

java 死锁

java 订阅
友情链接: ATR-趋势突破EA.zip