在安全性和活跃性之间通常存在着某种制衡

 

一、死锁

定义：在线程A持有锁L并想获得锁M的同时，线程B持有锁M并尝试获得锁L，线程AB均不会释放自己的锁，那么这两个线程将永远地等待下去

在数据库系统的设中考虑了检测死锁以及从死锁中恢复。JVM没有办法解决死锁，只能在编程和测试时注意不要让死锁发生

1、锁顺序死锁——两个线程试图以不同的顺序来获得相同的锁

解决：如果所有线程以固定的顺序来获得锁，那么在程序中就不会出现锁顺序死锁问题。

2、动态的锁顺序死锁

1 A: transferMoney(myAccount, yourAccount, 10);2 B: transferMoney(yourAccount, myAccount, 20);

使用Account中包含的唯一的不可变的并且具备可比性的键值或计算HashCode作为加锁顺序的依据

3、在协作对象间发生死锁

如果在持有锁时调用某个外部方法，那么将出现活跃性问题。在这个外部方法中可能会获取其他锁（这可能会产生死锁），或者阻塞时间过长，导致其他线程无法及时获得当前被持有的锁。

1 class Taxi { 2         @GuardedBy("this") private Point location, destination; 3         private final Dispatcher dispatcher; 4  5         public Taxi(Dispatcher dispatcher) { 6             this.dispatcher = dispatcher; 7         } 8  9         public synchronized Point getLocation() {10             return location;11         }12 13         public synchronized void setLocation(Point location) {14             this.location = location;15             if (location.equals(destination))16                 dispatcher.notifyAvailable(this);17         }18 19         public synchronized Point getDestination() {20             return destination;21         }22 23         public synchronized void setDestination(Point destination) {24             this.destination = destination;25         }26     }27 28     class Dispatcher {29         @GuardedBy("this") private final Set
      
        taxis;30         @GuardedBy("this") private final Set
       
         availableTaxis;31 32         public Dispatcher() {33             taxis = new HashSet
        
         ();34             availableTaxis = new HashSet
         
          ();35         }36 37         public synchronized void notifyAvailable(Taxi taxi) {38             availableTaxis.add(taxi);39         }40 41         public synchronized Image getImage() {42             Image image = new Image();43             for (Taxi t : taxis)44                 image.drawMarker(t.getLocation());45             return image;46         }47     }
         
        
       
      

taxi.setLocation(location) 和dispatcher.notifyAvailable(taxi)同时调用时会发生锁顺序死锁

4、开放调用——在调用某个方法时不需要持有锁

在程序中应尽量使用开放调用。与那些在持有锁时调用外部方法的程序相比，更易于对依赖于开放调用的程序进行死锁分析

1 class Taxi { 2         @GuardedBy("this") private Point location, destination; 3         private final Dispatcher dispatcher; 4  5         public Taxi(Dispatcher dispatcher) { 6             this.dispatcher = dispatcher; 7         } 8  9         public synchronized Point getLocation() {10             return location;11         }12 13         public synchronized void setLocation(Point location) {14             boolean reachedDestination;15             synchronized (this) {16                 this.location = location;17                 reachedDestination = location.equals(destination);18             }19             if (reachedDestination)20                 dispatcher.notifyAvailable(this);21         }22 23         public synchronized Point getDestination() {24             return destination;25         }26 27         public synchronized void setDestination(Point destination) {28             this.destination = destination;29         }30     }31 32     @ThreadSafe33     class Dispatcher {34         @GuardedBy("this") private final Set
      
        taxis;35         @GuardedBy("this") private final Set
       
         availableTaxis;36 37         public Dispatcher() {38             taxis = new HashSet
        
         ();39             availableTaxis = new HashSet
         
          ();40         }41 42         public synchronized void notifyAvailable(Taxi taxi) {43             availableTaxis.add(taxi);44         }45 46         public Image getImage() {47             Set
          
            copy;48             synchronized (this) {49                 copy = new HashSet
           
            (taxis);50 }51 Image image = new Image();52 for (Taxi t : copy)53 image.drawMarker(t.getLocation());54 return image;55 }56 }
           
          
         
        
       
      

5、资源死锁——两个线程分别持有彼此想要的资源而又不会释放

例：任务执行需要连接两个数据库，两个任务分别连接了其中一个数据库，而又等待彼此释放另一个数据库的资源

6、线程饥饿死锁——一个任务中提交另一个任务，并一直等待被提交任务完成

这些任务往往是产生线程饥饿死锁的主要来源，有界线程池 / 资源池与相互依赖的任务不能一起使用。

 

二、死锁的避免与诊断

如果一个线程每次至多只能获得一个锁，那么就不会产生锁顺序死锁。

如果必须获取多个锁，那么在设计时必须考虑锁的顺序：尽量减少潜在的加锁交互数量，将获取锁时需要遵循的协议写入正式文档并始终遵循这些文档。

1、支持定时锁

显式使用Lock类中的定时tryLock功能来代替内置锁机制，显式锁则可以指定一个超时时限，在等待超过该时间后tryLock会返回一个失败信息

• 当定时锁失败时，并不能确定是否由于死锁导致失败

即使不使用定时锁，使用能定时的锁，如果在获取锁时超时，那么可以释放当前的锁，在一段时间后再次尝试，从而消除了死锁发生的条件（在同时获取两个锁时有效）

2、通过线程转储信息来分析死锁

　　线程转储包括各个运行中的线程的栈追踪信息，这类似于发生异常时的栈追踪信息。线程转储还包括加锁信息，例如每个线程持有了哪些锁，在哪些栈帧中获得这些锁，以及被阻塞的线程正在等待获取哪一个锁。在生成线程转储之前，JVM将在等待关系图通过循环来找出死锁。如果发现了一个死锁，则获取相应的死锁信息，例如在死锁中涉及哪些锁和线程，以及这个锁的获取操作位于程序的哪些位置。

　　显示锁比在内置锁上获得的信息精确度低。内置锁与获得它们所在的线程栈帧是相关联的，而显式的Lock只与获得它的线程相关联。

 

三、其他活跃性危险

1、饥饿——线程由于无法访问它所需要的资源时而不能继续执行

• 例：持有锁时执行一些无法结束的结构；底优先级的任务获取不到CPU资源
• 要避免使用线程优先级，因为这会增加平台依赖性，并可能导致活跃性问题。在大多数并发应用程序中，都可以使用默认的线程优先级

2、糟糕的响应性

• 例：后台任务若为CPU密集型，将可能影响程序响应性
• 例：不良的锁管理，某个锁持有过长时间

 

3、活锁——线程将不断重复执行相同的操作，而且总会失败（不会阻塞线程，但也不能继续执行）

• 例：错误的事务运行失败放在队列头
• 例：多个相互协作的线程都对彼此进行响应从而修改各自的状态，并使得任何一个线程都无法继续执行（通过等待随机长度的时间和回退可以有效的避免活锁）