嵌套管程锁死是如何发生的
嵌套管程锁死的问题类似于死锁。 嵌套管程锁死是这样发生的：
Thread 1 synchronizes on A
Thread 1 synchronizes on B (while synchronized on A)
Thread 1 decides to wait for a signal from another thread before continuing
Thread 1 calls B.wait() thereby releasing the lock on B, but not A.
Thread 2 needs to lock both A and B (in that sequence)
to send Thread 1 the signal.
Thread 2 cannot lock A, since Thread 1 still holds the lock on A.
Thread 2 remain blocked indefinately waiting for Thread1
to release the lock on A
Thread 1 remain blocked indefinately waiting for the signal from
Thread 2, thereby
never releasing the lock on A, that must be released to make
it possible for Thread 2 to send the signal to Thread 1, etc.
这听起来像是一种理论上的情况，但是请看下面Lock的直接实现：
//带有嵌套管程锁死的lock实现
public class Lock{
protected MonitorObject monitorObject = new MonitorObject();
protected boolean isLocked = false;
public void lock() throws InterruptedException{
synchronized(this){
while(isLocked){
synchronized(this.monitorObject){
this.monitorObject.wait();
}
}
isLocked = true;
}
}
public void unlock(){
synchronized(this){
this.isLocked = false;
synchronized(this.monitorObject){
this.monitorObject.notify();
}
}
}
}
请注意lock（）方法首先在“ this”上同步，然后在monitorObject成员变量上同步。 如果isLocked为false，则没有问题。 该线程不调用monitorObject.wait（）。 但是，如果isLocked为true，则调用lock（）的线程将停在monitorObject.wait（）调用中。
这样做的问题在于，调用monitorObject.wait（）仅释放了monitorObject成员上的同步管程，而不释放与“ this”关联的同步管程。 换句话说，刚刚停在等待状态的线程仍持有“ this”上的同步锁。
当首个将Lock锁定的线程尝试调用unlock（）对其进行解锁时，将在尝试进入unlock（）方法中的synchronized(this)代码块时被阻塞。 它将一直保持阻塞状态，直到在lock（）中等待的线程离开了synchronized（this）为止。 但是，在lock（）方法中等待的线程不会离开该块，直到isLocked 设置为false，并执行monitorObject.notify（），而这正是unlock（）要做的。
简而言之，等待lock（）的线程需要成功执行一次unlock（），以使其退出lock（）和其中的同步块。 但是，在lock()中等待的线程离开外部同步块之前，没有任何线程可以实际执行unlock（）。
结果是，任何调用lock（）或unlock（）的线程都将永远阻塞。 这称为嵌套管程锁死。
一个更现实的例子
你可能会说，你永远不会照上面的方式实现一个锁。 因为你不会在内部管程对象上调用wait（）和notify（），而是在this上调用。很可能是这样。 但是在某些情况下，可能会出现上述设计。 例如，如果要在Lock中实现公平性。 这样做时，你希望每个线程在各自的队列对象上调用wait（），以便可以一次通知一个线程。
看一下这种公平锁的简单实现：
//Fair Lock implementation with nested monitor lockout problem
public class FairLock {
private boolean isLocked = false;
private Thread lockingThread = null;
private List<QueueObject> waitingThreads =
new ArrayList<QueueObject>();
public void lock() throws InterruptedException{
QueueObject queueObject = new QueueObject();
synchronized(this){
waitingThreads.add(queueObject);
while(isLocked || waitingThreads.get(0) != queueObject){
synchronized(queueObject){
try{
queueObject.wait();
}catch(InterruptedException e){
waitingThreads.remove(queueObject);
throw e;
}
}
}
waitingThreads.remove(queueObject);
isLocked = true;
lockingThread = Thread.currentThread();
}
}
public synchronized void unlock(){
if(this.lockingThread != Thread.currentThread()){
throw new IllegalMonitorStateException(
"Calling thread has not locked this lock");
}
isLocked = false;
lockingThread = null;
if(waitingThreads.size() > 0){
QueueObject queueObject = waitingThreads.get(0);
synchronized(queueObject){
queueObject.notify();
}
}
}
}
public class QueueObject {
}
乍看起来，此实现看起来不错，但请注意lock（）方法调用了queueObject.wait（），该调用在两个同步块内部。 一个在“ this”上同步，另一个嵌套在其中，在queueObject局部变量上同步。 当线程调用queueObject.wait（）时，它释放QueueObject实例上的锁，但不释放与“ this”关联的锁。
还要注意，unlock（）方法声明为synchronized，它相当于synchronized（this）块。 这意味着，如果线程在lock（）中等待，则与“ this”关联的管程对象将被该等待的线程锁定。 所有调用unlock（）的线程将无限期地阻塞，等待正在等待的线程释放对“ this”的锁定。 但这永远不会发生，因为只有在线程成功将信号发送到等待的线程时才会发生，而发送信号只能通过执行unlock（）方法。
因此，上面的FairLock实现可能导致嵌套管程锁死。在《饥饿和公平性》篇中讲解了如何更好的实现公平锁。
嵌套管程锁死 vs 死锁
嵌套管程锁死和死锁的结果几乎相同：所涉及的线程最终被阻塞，永远等待对方。
但这两种情况并不等价。 如关于死锁篇中所述，当两个线程以不同顺序获得锁时，就会发生死锁。 线程1锁定A，等待B。线程2锁定B，然后等待A。如防死锁篇所述，可以通过始终以相同顺序锁定锁（锁定顺序）来避免死锁。 但是，嵌套管程锁死正是由两个线程以相同顺序进行锁定而发生。 线程1锁定A和B，然后释放B并等待来自线程2的信号。线程2同时需要A和B才能向线程1发送信号。 结果就是，一个线程正在等待信号，另一个线程正在等待释放锁。
区别总结如下：
- 在死锁中，两个线程等待彼此释放锁。
- 嵌套管程锁死中，线程1持有锁A，然后等待
来自线程2的信号。线程2需要锁A来发送
信号给线程1。