在JAVA并发编程中，我们使用锁来确保可变共享变量的安全性。要注意的是，不正确的使用锁很容易导致死锁。 

死锁的4个必要条件
： 

1. 互斥访问 

2. 非抢占 

3. 持有并等待 

4. 循环等待 

在JAVA编程中，有3种典型的死锁类型：
 

静态的锁顺序死锁，动态的锁顺序死锁，协作对象之间发生的死锁。 

静态的锁顺序死锁：
 

a和b两个方法都需要获得A锁和B锁。一个线程执行a方法且已经获得了A锁，在等待B锁；另一个线程执行了b方法且已经获得了B锁，在等待A锁。这种状态，就是发生了静态的锁顺序死锁。 

Java代码  

1. //可能发生静态锁顺序死锁的代码  
2. class StaticLockOrderDeadLock{  
3.     private final Object lockA=new Object();  
4.     private final Object lockB=new Object();  
5.     public void a(){  
6.         synchronized (lockA) {  
7.             synchronized (lockB) {  
8.                 System.out.println(“function a”);  
9.             }  
10.         }  
11.     }  
12.       
13.     public void b(){  
14.         synchronized (lockB) {  
15.             synchronized (lockA) {  
16.                 System.out.println(“function b”);  
17.             }  
18.         }  
19.     }  
20. }  

解决静态的锁顺序死锁的方法就是：所有需要多个锁的线程，都要以相同的顺序来获得锁。
 

Java代码  

1. //正确的代码  
2. class StaticLockOrderDeadLock{  
3.     private final Object lockA=new Object();  
4.     private final Object lockB=new Object();  
5.     public void a(){  
6.         synchronized (lockA) {  
7.             synchronized (lockB) {  
8.                 System.out.println(“function a”);  
9.             }  
10.         }  
11.     }  
12.       
13.     public void b(){  
14.         synchronized (lockA) {  
15.             synchronized (lockB) {  
16.                 System.out.println(“function b”);  
17.             }  
18.         }  
19.     }  
20. }  

动态的锁顺序死锁：
 

动态的锁顺序死锁是指两个线程调用同一个方法时，传入的参数颠倒造成的死锁。如下代码，一个线程调用了transferMoney方法并传入参数accountA,accountB；另一个线程调用了transferMoney方法并传入参数accountB,accountA。此时就可能发生在静态的锁顺序死锁中存在的问题，即：第一个线程获得了accountA锁并等待accountB锁，第二个线程获得了accountB锁并等待accountA锁下载地址   。 

Java代码  

1. //可能发生动态锁顺序死锁的代码  
2. class DynamicLockOrderDeadLock{  
3.     public void transefMoney(Account fromAccount,Account toAccount,Double amount){  
4.         synchronized (fromAccount) {  
5.             synchronized (toAccount) {  
6.                 //…  
7.                 fromAccount.minus(amount);  
8.                 toAccount.add(amount);  
9.                 //…  
10.             }  
11.         }  
12.     }  
13. }  

动态的锁顺序死锁解决方案如下：使用System.identifyHashCode来定义锁的顺序。确保所有的线程都以相同的顺序获得锁
 

Java代码  

1. //正确的代码  
2. class DynamicLockOrderDeadLock{  
3.     private final Object myLock=new Object();  
4.     public void transefMoney(final Account fromAccount,final Account toAccount,final Double amount){  
5.         class Helper{  
6.             public void transfer(){  
7.                 //…  
8.                 fromAccount.minus(amount);  
9.                 toAccount.add(amount);  
10.                 //…  
11.             }  
12.         }  
13.         int  fromHash=System.identityHashCode(fromAccount);  
14.         int  toHash=System.identityHashCode(toAccount);  
15.           
16.         if(fromHash<toHash){  
17.             synchronized (fromAccount) {  
18.                 synchronized (toAccount) {  
19.                     new Helper().transfer();  
20.                 }  
21.             }  
22.         }else if(fromHash>toHash){  
23.             synchronized (toAccount) {  
24.                 synchronized (fromAccount) {  
25.                     new Helper().transfer();  
26.                 }  
27.             }  
28.         }else{  
29.             synchronized (myLock) {  
30.                 synchronized (fromAccount) {  
31.                     synchronized (toAccount) {  
32.                         new Helper().transfer();  
33.                     }  
34.                 }  
35.             }  
36.         }  
37.           
38.     }  
39. }  

协作对象之间发生的死锁：
 

有时，死锁并不会那么明显，比如两个相互协作的类之间的死锁，比如下面的代码：一个线程调用了Taxi对象的setLocation方法，另一个线程调用了Dispatcher对象的getImage方法。此时可能会发生，第一个线程持有Taxi对象锁并等待Dispatcher对象锁，另一个线程持有Dispatcher对象锁并等待Taxi对象锁。 

Java代码  

1. //可能发生死锁  
2. class Taxi{  
3.     private Point location,destination;  
4.     private final Dispatcher dispatcher;  
5.     public Taxi(Dispatcher dispatcher) {  
6.         this.dispatcher=dispatcher;  
7.     }  
8.     public synchronized Point getLocation(){  
9.         return location;  
10.     }  
11.     public synchronized void setLocation(Point location){  
12.         this.location=location;  
13.         if(location.equals(destination))  
14.             dispatcher.notifyAvailable(this);//外部调用方法，可能等待Dispatcher对象锁  
15.     }  
16. }  
17. class Dispatcher{  
18.     private final Set<Taxi> taxis;  
19.     private final Set<Taxi> availableTaxis;  
20.     public Dispatcher(){  
21.         taxis=new HashSet<Taxi>();  
22.         availableTaxis=new HashSet<Taxi>();  
23.     }  
24.     public synchronized void notifyAvailable(Taxi taxi){  
25.         availableTaxis.add(taxi);  
26.     }  
27.     public synchronized Image getImage(){  
28.         Image image=new Image();  
29.         for(Taxi t:taxis)  
30.             image.drawMarker(t.getLocation());//外部调用方法，可能等待Taxi对象锁  
31.         return image;  
32.     }  
33. }  

上面的代码中，我们
在持有锁的情况下调用了外部的方法，这是非常危险的（可能发生死锁）
。为了避免这种危险的情况发生，我们使用开放调用。
如果调用某个外部方法时不需要持有锁，我们称之为开放调用。
 

解决协作对象之间发生的死锁：需要使用开放调用，即避免在持有锁的情况下调用外部的方法。
 

Java代码  

1. //正确的代码  
2. class Taxi{  
3.     private Point location,destination;  
4.     private final Dispatcher dispatcher;  
5.     public Taxi(Dispatcher dispatcher) {  
6.         this.dispatcher=dispatcher;  
7.     }  
8.     public synchronized Point getLocation(){  
9.         return location;  
10.     }  
11.     public void setLocation(Point location){  
12.         boolean flag=false;  
13.         synchronized (this) {  
14.             this.location=location;  
15.             flag=location.equals(destination);            
16.         }  
17.         if(flag)  
18.             dispatcher.notifyAvailable(this);//使用开放调用  
19.     }  
20. }  
21. class Dispatcher{  
22.     private final Set<Taxi> taxis;  
23.     private final Set<Taxi> availableTaxis;  
24.     public Dispatcher(){  
25.         taxis=new HashSet<Taxi>();  
26.         availableTaxis=new HashSet<Taxi>();  
27.     }  
28.     public synchronized void notifyAvailable(Taxi taxi){  
29.         availableTaxis.add(taxi);  
30.     }  
31.     public Image getImage(){  
32.         Set<Taxi> copy;  
33.         synchronized (this) {  
34.             copy=new HashSet<Taxi>(taxis);  
35.         }  
36.         Image image=new Image();  
37.         for(Taxi t:copy)  
38.             image.drawMarker(t.getLocation());//使用开放调用  
39.         return image;  
40.     }  
41. }  

综上，是常见的3种死锁的类型。即：静态的锁顺序死锁，动态的锁顺序死锁，协作对象之间的死锁。在写代码时，要确保线程在获取多个锁时采用一致的顺序。同时，要避免在持有锁的情况下调用外部方法。