16.死锁

线程死锁

一个死锁是当正在等待获取锁的两个或者更多的线程被锁住的时候，在死锁中的其他线程也持有了这个锁。死锁发生在当多个线程同时需要相同的锁的时候，但是在不同的顺序中获取它。

例如，如果线程1锁住A并且尝试去锁B，以及线程2已经锁住B了并且尝试去锁A，一个死锁就产生了。线程1不会得到B，线程2不会得到A。另外，他们中的任何一个都不会知道。他们将会互相保持锁定状态，A和B，永远。这个场景就是一个死锁。

这个场景如下所示：

Thread 1  locks A, waits for B
Thread 2  locks B, waits for A

这里有一个例子，一个树节点类在不同的实例中调用同步方法：

public class TreeNode {
 
  TreeNode parent   = null;  
  List     children = new ArrayList();

  public synchronized void addChild(TreeNode child){
    if(!this.children.contains(child)) {
      this.children.add(child);
      child.setParentOnly(this);
    }
  }
  
  public synchronized void addChildOnly(TreeNode child){
    if(!this.children.contains(child){
      this.children.add(child);
    }
  }
  
  public synchronized void setParent(TreeNode parent){
    this.parent = parent;
    parent.addChildOnly(this);
  }

  public synchronized void setParentOnly(TreeNode parent){
    this.parent = parent;
  }
}

如果一个线程1调用parent.addChild(child)方法，同时另外一个线程2调用这个child.setParent(parent)方法，在相同的parent和child实例上，一个死锁就发生了。这里有一个伪代码如下：

Thread 1: parent.addChild(child); //locks parent
          --> child.setParentOnly(parent);

Thread 2: child.setParent(parent); //locks child
          --> parent.addChildOnly()

首先线程1调用parent.addChild(child)。因为addChild方法是同步的将会锁住对于其他线程访问的parent对象。

然后线程2调用child.setParent(parent)。因为setParent是同步的也会锁住访问其他线程的child对象。

现在child和parent对象被两个不同的线程锁住了。下一个线程1试着调用child.setParentOnly方法，但是这个child对象被线程2锁住了，以至于这个方法调用就锁住了。线程2也会尝试调用parent.addChildOnly方法，但是这个parent对象被线程1锁住了，引起线程2去锁住这个方法调用。现在两个线程都被锁住了去等待获取其他线程持有的锁。

注意：这两个线程如上面描述的必须同时调用parent.addChild(child)和child.setParent(parent)，以及在相同的两个parent和child实例上，死锁就会发生了。上面的代码可能会很长一段时间执行的很好直到一个突然的死锁发生。

这个线程真正的需要同时去获取这个锁。例如，线程1比线程2提前一点，以及锁住A和B，然后线程2将会被锁住当尝试去锁B的时候。然后没有死锁发生。因为线程调度经常是不可预料的，这里没有办法去预料什么时间一个死锁发生。只是那个可以发生的时候。

更加复杂的死锁

死锁也包括超过两个线程。这个就使得很难去检测到。这里有一个四个线程死锁的例子：

Thread 1  locks A, waits for B
Thread 2  locks B, waits for C
Thread 3  locks C, waits for D
Thread 4  locks D, waits for A

线程1等待线程2，线程2等待线程3，线程3等待线程4，线程4等待线程1。

数据库死锁

一个更复杂的死锁发生的条件是数据库事物。一个数据库事物可能包含许多的SQL更新请求。在一个事物期间当一条记录被更新的时候，那条记录就会锁住来自其他事物的更新，直到第一个事物完成。在相同的事物内每一个更新请求因此可能会锁住数据库中的一些记录。

如果多个事物同时正在运行并且需要去更新相同的记录，这里就会有一个死锁发生的风险：

Transaction 1, request 1, locks record 1 for update
Transaction 2, request 1, locks record 2 for update
Transaction 1, request 2, tries to lock record 2 for update.
Transaction 2, request 2, tries to lock record 1 for update.

因为这个锁被携带在不同的请求中，并且并不是所有需要给予一个事物的锁会提前知道，它是很难检测或者避免死锁的在数据库事物中。

翻译地址：http://tutorials.jenkov.com/java-concurrency/deadlock.html