JAVA并发-3种典型的死锁

来源:互联网 发布:java 微信发送消息 编辑:程序博客网 时间:2021/04/12 14:33
在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种死锁的类型。即:静态的锁顺序死锁,动态的锁顺序死锁,协作对象之间的死锁。在写代码时,要确保线程在获取多个锁时采用一致的顺序。同时,要避免在持有锁的情况下调用外部方法。
0 0