并发编程八：死锁

转载：https://www.cnblogs.com/xujingyang/p/6677160.html

概念：当一个线程永远地持有一个锁，并且其他线程都尝试去获得这个锁时。
如果线程A持有锁L并且想获得锁M，线程B持有锁M并且想获得锁L，那么这两个线程将永远等待下去，这种情况就是最简单的死锁形式。

一、死锁实现

//死锁类(注意这里一定要有"Thread.sleep(2000)"让线程睡一觉，不然一个线程运行了，另一个线程还没有运行，先运行的线程很有可能就已经连续获得两个锁了)
public class DeadLock {
      
      private final Object    left    = new Object() ;
      private final Object    right    = new Object() ;
      
     public void left() throws Exception {
          synchronized (left) {
             Thread.sleep(2000) ;
             synchronized (right) {
                 System.out.println("左边") ;
             }
         }
     }
     
     public void right() throws Exception {
         synchronized (right) {
             Thread.sleep(2000) ;
               synchronized (left) {
                 System.out.println("右边") ;
             }
         }
     }
 }

 //多线程执行代理类
 package com.xujingyang.DeadLock ;
 
 public class ProxyLeftLock extends Thread {
     
     private DeadLock    lock ;
     
     public ProxyLeftLock(DeadLock lock) {
         this.lock = lock ;
     }
     
     @Override
     public void run() {
         try {
             lock.left() ;
         } catch (Exception e) {
             e.printStackTrace() ;
         }
     }
     
 }

 //多线程执行代理类
 package com.xujingyang.DeadLock ;
 
 public class ProxyRightLock extends Thread {
     
     private DeadLock    lock ;
     
     public ProxyRightLock(DeadLock lock) {
         this.lock = lock ;
     }
     
     @Override
     public void run() {
         try {
             lock.right() ;
         } catch (Exception e) {
             e.printStackTrace() ;
         }
     }
     
 }

//测试类
package com.xujingyang.DeadLock ;
 
 public class MainTest {
     
     public static void main(String [] args) {
         DeadLock lock = new DeadLock() ;
         new ProxyLeftLock(lock).start() ;
         new ProxyRightLock(lock).start() ;
     }
 }

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

二、死锁分析

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、利用taskkill命令去终止没有被Terminate的进程

避免死锁的方式
既然可能产生死锁，那么接下来，讲一下如何避免死锁。
（1）让程序每次至多只能获得一个锁。当然，在多线程环境下，这种情况通常并不现实
（2）设计时考虑清楚锁的顺序，尽量减少嵌在的加锁交互数量
（3）既然死锁的产生是两个线程无限等待对方持有的锁，那么只要等待时间有个上限不就好了。当然synchronized不具备这个功能，但是我们可以使用Lock类中的tryLock方法去尝试获取锁，这个方法可以指定一个超时时限，在等待超过该时限之后变回返回一个失败信息