深入理解多线程,死锁再现

先说说死锁概念:

     当一个线程永远地持有一个锁,并且其他线程都尝试去获得这个锁时,那么它们将永远被阻塞,这个我们都知道。如果线程A持有锁L并且想获得锁M,线程B持有锁M并且想获得锁L,那么这两个线程将永远等待下去,这种情况就是最简单的死锁形式。

     在数据库系统的设计中考虑了监测死锁以及从死锁中恢复,数据库如果监测到了一组事物发生了死锁时,将选择一个牺牲者并放弃这个事物。Java虚拟机解决死锁问题方面并没有数据库这么强大,当一组Java线程发生死锁时,这两个线程就永远不能再使用了,并且由于两个线程分别持有了两个锁,那么这两段同步代码/代码块也无法再运行了----除非终止并重启应用。

  死锁是设计的BUG,问题比较隐晦。不过死锁造成的影响很少会立即显现出来,一个类可能发生死锁,并不意味着每次都会发生死锁,这只是表示有可能。当死锁出现时,往往是在最糟糕的情况----高负载的情况下

 

看了网上博客的例子,自己实战了一下:

 

死锁类(注意这里一定要有"Thread.sleep(2000)"让线程睡一觉,不然一个线程运行了,另一个线程还没有运行,先运行的线程很有可能就已经连续获得两个锁了)

 1 package com.xujingyang.DeadLock ;
 2 
 3 public class DeadLock {
 4     
 5     private final Object    left    = new Object() ;
 6     private final Object    right    = new Object() ;
 7     
 8     public void left() throws Exception {
 9         synchronized (left) {
10             Thread.sleep(2000) ;
11             synchronized (right) {
12                 System.out.println("左边") ;
13             }
14         }
15     }
16     
17     public void right() throws Exception {
18         synchronized (right) {
19             Thread.sleep(2000) ;
20             synchronized (left) {
21                 System.out.println("右边") ;
22             }
23         }
24     }
25 }

 

多线程执行代理类

 1 package com.xujingyang.DeadLock ;
 2 
 3 public class ProxyLeftLock extends Thread {
 4     
 5     private DeadLock    lock ;
 6     
 7     public ProxyLeftLock(DeadLock lock) {
 8         this.lock = lock ;
 9     }
10     
11     @Override
12     public void run() {
13         try {
14             lock.left() ;
15         } catch (Exception e) {
16             e.printStackTrace() ;
17         }
18     }
19     
20 }

 

 1 package com.xujingyang.DeadLock ;
 2 
 3 public class ProxyRightLock extends Thread {
 4     
 5     private DeadLock    lock ;
 6     
 7     public ProxyRightLock(DeadLock lock) {
 8         this.lock = lock ;
 9     }
10     
11     @Override
12     public void run() {
13         try {
14             lock.right() ;
15         } catch (Exception e) {
16             e.printStackTrace() ;
17         }
18     }
19     
20 }

 

测试类

 1 package com.xujingyang.DeadLock ;
 2 
 3 public class MainTest {
 4     
 5     public static void main(String [] args) {
 6         DeadLock lock = new DeadLock() ;
 7         new ProxyLeftLock(lock).start() ;
 8         new ProxyRightLock(lock).start() ;
 9     }
10 }

 

结果什么也没打印,因为已经形成了死锁.

1、jps获得当前Java虚拟机进程的pid

 

2、jstack打印堆栈。jstack打印内容的最后其实已经报告发现了一个死锁,但因为我们是分析死锁产生的原因,而不是直接得到这里有一个死锁的结论,所以别管它,就看前面的部分

先说明介绍一下每一部分的意思,以"Thread-1"为例:

(1)"Thread-1"表示线程名称

(2)"prio=6"表示线程优先级

(3)"tid=00000000497cec00"表示线程Id

(4)nid=0x219c

  线程对应的本地线程Id,这个重点说明下。因为Java线程是依附于Java虚拟机中的本地线程来运行的,实际上是本地线程在执行Java线程代码,只有本地线程才是真正的线程实体。Java代码中创建一个thread,虚拟机在运行期就会创建一个对应的本地线程,而这个本地线程才是真正的线程实体。Linux环境下可以使用"top -H -p JVM进程Id"来查看JVM进程下的本地线程(也被称作LWP)信息,注意这个本地线程是用十进制表示的,nid是用16进制表示的,转换一下就好了

(5)" [0x000000000c9ff000]"表示线程占用的内存地址

(6)"java.lang.Thread.State:BLOCKED"表示线程的状态

    解释完了每一部分的意思,看下Thread-1处于BLOCKED状态,Thread-0处于BLOCKED状态。对这两个线程分析一下:

(1)Thread-1获得了锁<0x00000007d5d19c60>,在等待锁<0x00000007d5d19c50>

(2)Thread-0获得了锁<0x00000007d5d19c50>,在等待锁<0x00000007d5d19c60>

  由于两个线程都在等待获取对方持有的锁,所以就这么永久等待下去了。

3、注意一下使用Eclipse/MyEclipse,这段程序如果不点击控制台上面的红色方框去Terminate掉它,而是右键->Run As->1 Java Application的话,这个进程会一直存在的,这时候可以利用taskkill命令去终止没有被Terminate的进程:

 

避免死锁的方式

  既然可能产生死锁,那么接下来,讲一下如何避免死锁。

1、让程序每次至多只能获得一个锁。当然,在多线程环境下,这种情况通常并不现实

2、设计时考虑清楚锁的顺序,尽量减少嵌在的加锁交互数量

3、既然死锁的产生是两个线程无限等待对方持有的锁,那么只要等待时间有个上限不就好了。当然synchronized不具备这个功能,但是我们可以使用Lock类中的tryLock方法去尝试获取锁,这个方法可以指定一个超时时限,在等待超过该时限之后变回返回一个失败信息

 

       参考博客:http://www.cnblogs.com/xrq730/p/4853713.html

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值