《Java并发编程实战》【第三部分 活跃性、性能与测试】

第10章 避免活跃性危险

   在安全性与活跃性之间通常存在着某种制衡。我们使用加锁机制来确保线程安全，但如果过度地使用加锁，则可能导致锁顺序死锁（Lock-Ordering Deadlock）。同样，我们使用线程池和信号量来限制对资源的使用，但这些被限制的行为可能会导致资源死锁（Resource Deadlock）。Java应用程序无法从死锁中恢复过来，因此在设计时一定要排除那些可能导致死锁出现的条件。本章将介绍一些导致活跃性故障的原因，以及如何避免它们。

10.1 死锁

   经典的“哲学家进餐”问题很好地描述了死锁状况。5个哲学家去吃中餐，坐在一张圆桌旁。他们有5根筷子（而不是5双），并且每两个人中间放一根筷子。哲学家们时而思考，时而进餐。每个人都需要一双筷子才能吃到东西，并在吃完后将筷子放回原处继续思考。有些筷子管理算法能够使每个人都能相对及时地吃到东西（例如一个饥饿的哲学家会尝试获得两根邻近的筷子，但如果其中一根正在被另一个哲学家使用，那么他将放弃已经得到的那根筷子，并等待几分钟之后再次尝试），但有些算法却可能导致一些或者所有哲学家都“饿死”（每个人都立即抓住自己左边的筷子，然后等待自己右边的筷子空出来，但同时又不放下已经拿到的筷子）。后一种情况将产生死锁：每个人都拥有其他人需要的资源，同时又等待其他人已经拥有的资源，并且每个人在获得所有需要的资源之前都不会放弃已经拥有的资源。
   当一个线程永远地持有一个锁，并且其他线程都尝试获得这个锁时，那么它们将永远被阻塞。在线程A持有锁L并想获得锁M的同时，线程B持有锁M并尝试获得锁L，那么这两个线程将永远地等待下去。这种情况就是最简单的死锁形式（或者称为“抱死[Deadly Embrace]”），其中多个线程由于存在环路的锁依赖关系而永远地等待下去。（把每个线程假想为有向图中的一个节点，图中每条边表示的关系是：“线程A等待线程B所占有的资源”。如果在图中形成了一条环路，那么就存在一个死锁。）
   在数据库系统的设计中考虑了监测死锁以及从死锁中恢复。在执行一个事务（Transaction）时可能需要获取多个锁，并一直持有这些锁直到事务提交。因此在两个事务之间很可能发生死锁，但事实上这种情况并不多见。如果没有外部干涉，那么这些事务将永远等待下去（在某个事务中持有的锁可能在其他事务中也需要）。但数据库服务器不会让这种情况发生。当它检测到一组事务发生了死锁时（通过在表示等待关系的有向图中搜索循环），将选择一个牺牲者并放弃这个事务。作为牺牲者的事务会释放它所持有的资源，从而使其他事务继续进行。应用程序可以重新执行被强行中止的事务，而这个事务现在可以成功完成，因为所有跟它竞争资源的事务都已经完成了。
   JVM在解决死锁问题方面并没有数据库服务那样强大。当一组Java线程发生死锁时，“游戏”将到此结束——这些线程永远不能再使用了。根据线程完成工作的不同，可能造成应用程序完全停止，或者某个特定的子系统停止，或者是性能降低。恢复应用程序的唯一方式就是中止并重启它，并希望不要再发生同样的事情。
   与许多其他的并发危险一样，死锁造成的影响很少会立即显现出来。如果一个类可能发生死锁，那么并不意味着每次都会发生死锁，而只是表示有可能。当死锁出现时，往往是在最糟糕的时候——在高负载情况下。

10.1.1 锁顺序死锁

   程序清单10-1中的LeftRightDeadlock存在死锁风险。leftRight和rightLeft这两个方法分别获得left锁和right锁。如果一个线程调用了leftRight，而另一个线程调用了rightLeft，并且这两个线程的操作是交错执行，如图10-1所示，那么它们会发生死锁。

   在LeftRightDeadlock中发生死锁的原因是：两个线程试图以不同的顺序来获得相同的锁。如果按照相同的顺序来请求锁，那么就不会出现循环的加锁依赖性，因此也就不会产生死锁。如果每个需要锁L和锁M的线程都以相同的顺序来获取L和M，那么就不会发生死锁了。
   如果所有线程以固定的顺序来获得锁，那么在程序中就不会出现锁顺序死锁问题。
   要想验证锁顺序的一致性，需要对程序中的加锁行为进行全局分析。如果只是单独地分析每条获取多个锁的代码路径，那是不够的：leftRight和rightLeft都采用了“合理的”方式来获得锁，它们只是不能相互兼容。当需要加锁时，它们需要知道彼此正在执行什么操作。
   程序清单10-1　简单的锁顺序死锁（不要这么做）

public class LeftRightDeadlock {
   
  private final Object left = new Object();
  private final Object right = new Object();

  public void leftRight() {
   
    synchronized (left) {
   
      synchronized (right) {
   
        // soSomething
      }
    }
  }
  public void rightLeft() {
   
    synchronized (right) {
   
      synchronized (left) {
   
        // soSomething
      }
    }
  }
}

10.1.2 动态的锁顺序死锁

   有时候，并不能清楚地知道是否在锁顺序上有足够的控制权来避免死锁的发生。考虑程序清单10-2中看似无害的代码，它将资金从一个账户转入另一个账户。在开始转账之前，首先要获得这两个Account对象的锁，以确保通过原子方式来更新两个账户中的余额，同时又不破坏一些不变性条件，例如“账户的余额不能为负数”。
   程序清单10-2　动态的锁顺序死锁（不要这么做）

public void tarnsferMoney(Account formAccount,Account toAccunt,
                            DollarAmount amount)
throws InsufficientResourcesException 
{
   
  synchronized (formAccount) {
   
    synchronized (toAccunt) {
   
      if (formAccount.getBalance().compareTo(amount)<0) {
   
        throw new InsufficientResourcesException();
      } else {
   
        formAccount.debit(amount);
        toAccunt.credit(amount);
      }
    }
  }
}

   在transferMoney中如何发生死锁？所有的线程似乎都是按照相同的顺序来获得锁，但事实上锁的顺序取决于传递给transferMoney的参数顺序，而这些参数顺序又取决于外部输入。如果两个线程同时调用transferMoney，其中一个线程从X向Y转账，另一个线程从Y向X转账，那么就会发生死锁：

// A: transferMonry(myAccount, yourAccount, 10);
// B: transferMonry(yourAccount, myAccount, 20);

   如果执行时序不当，那么A可能获得myAccount的锁并等待yourAccount的锁，然而B此时持有yourAccount的锁，并正在等待myAccount的锁。
   这种死锁可以采用程序清单10-1中的方法来检查——查看是否存在嵌套的锁获取操作。由于我们无法控制参数的顺序，因此要解决这个问题，必须定义锁的顺序，并在整个应用程序中都按照这个顺序来获取锁。
   在制定锁的顺序时，可以使用System.identityHashCode方法，该方法将返回由Object.hashCode返回的值。程序清单10-3给出了另一个版本的transferMoney，在该版本中使用了System.identityHashCode来定义锁的顺序。虽然增加了一些新的代码，但却消除了发生死锁的可能性。
   程序清单10-3　通过锁顺序来避免死锁

private static final Object tieLock = new Object();
public void transfermoney(final Account fromAccount,
                           final Account toAccount,
                           final BigDecimal amount)
throws InsufficientResourcesException {
   
  class Helper {
   
    public void transfer() throws InsufficientResourcesException {
   
      if (fromAccount.getBalance().compareTo(amount)<0) {
   
        throw new InsufficientResourcesException();
      } else {
   
        fromAccount.debit(amount);
        toAccount.debit(amount);
      }
    }
  }
  int fromHash = System.identityHashCode(fromAccount);
  int toHash = System.identityHashCode(toAccount);
  if (fromHash<toHash) {
   
    synchronized (fromAccount) {
   
      synchronized (toAccount) {
   
        new Helper().transfer();
      }
    }
  } else if (fromHash>toHash) {
   
    synchronized (toAccount) {
   
      synchronized (fromAccount) {
   
        new Helper().transfer();
      }
    }
  } else {
   
    synchronized (tieLock) {
   
      synchronized (fromAccount) {
   
        synchronized (toAccount) {
   
          new Helper().transfer();
        }
      }
    }
  }
}

   在极少数情况下，两个对象可能拥有相同的散列值，此时必须通过某种任意的方法来决定锁的顺序，而这可能又会重新引入死锁。为了避免这种情况，可以使用“加时赛（Tie-Breaking）”锁。在获得两个Account锁之前，首先获得这个“加时赛”锁，从而保证每次只有一个线程以未知的顺序获得这两个锁，从而消除了死锁发生的可能性（只要一致地使用这种机制）。如果经常会出现散列冲突的情况，那么这种技术可能会成为并发性的一个瓶颈（这类似于在整个程序中只有一个锁的情况），但由于System.identityHashCode中出现散列冲突的频率非常低，因此这项技术以最小的代价，换来了最大的安全性。
   如果在Account中包含一个唯一的、不可变的，并且具备可比性的键值，例如账号，那么要制定锁的顺序就更加容易了：通过键值对对象进行排序，因而不需要使用“加时赛”锁。
   你或许认为我有些夸大了死锁的风险，因为锁被持有的时间通常很短暂，然而在真实系统中，死锁往往都是很严重的问题。作为商业产品的应用程序每天可能要执行数十亿次获取锁-释放锁的操作。只要在这数十亿次操作中有一次发生了错误，就可能导致程序发生死锁，并且即使应用程序通过了压力测试也不可能找出所有潜在的死锁【具有讽刺意味的是，之所以短时间地持有锁，是为了降低锁的竞争程度，但却增加了在测试中找出潜在死锁风险的难度。】在程序清单l0-4【为了简便，在DemonstrateDeadlock没有考虑账户余额为负数的问题。】中的DemonstrateDeadlock在大多数系统下都会很快发生死锁。
   程序清单10-4　在典型条件下会发生死锁的循环

10.1.3 在协作对象之间发生的死锁

   某些获取多个锁的操作并不像在LeftRightDeadlock或transferMoney中那么明显，这两个锁并不一定必须在同一个方法中被获取。考虑程序清单10-5中两个相互协作的类，在出租车调度系统中可能会用到它们。Taxi代表一个出租车对象，包含位置和目的地两个属性，Dispatcher代表一个出租车车队。
   程序清单10-5　在相互协作对象之间的锁顺序死锁（不要这么做）

class Taxi {
   
  @GuardedBy("this") private Point location, destination;
  private final Dispatcher dispatcher;

  public Taxi(Dispatcher dispatcher) {
    this.dispatcher = dispatcher; }
  public synchronized Point getLocation() {
    return location; }
  public synchronized void setLocation(Point location) {
   
    this.location = location;
    if (location.equals(destination)) {
   
      dispatcher.notifyAvailable(this);
    }
  }
}
class Dispatcher {
   
  @GuardedBy("this") private final Set<Taxi> taxis;
  @GuardedBy("this") private final Set<Taxi> availableTaxi;

  public Dispatcher() {
   
    taxis = new HashSet<Taxi>();
    availableTaxi = new HashSet<Taxi>();
  }
  public synchronized void notifyAvailable(Taxi taxi) {
   
    availableTaxi.add(taxi);
  }
  public synchronized Image getImage() {
   
    Image image = new Image();
    for (Taxi t : taxis) {
   
      image.drawMaker(t.getLocation());
    }
    return image;
  }
}

   尽管没有任何方法会显式地获取两个锁，但setLocation和getImage等方法的调用者都会获得两个锁。如果一个线程在收到GPS接收器的更新事件时调用setLocation，那么它将首先更新出租车的位置，然后判断它是否到达了目的地。如果已经到达，它会通知Dispatcher：它需要一个新的目的地。因为setLocation和notifyAvailable都是同步方法，因此调用setLocation的线程将首先获取Taxi的锁，然后获取Dispatcher的锁。同样，调用getImage的线程将首先获取Dispatcher锁，然后再获取每一个Taxi的锁（每次获取一个）。这与LeftRightDeadlock中的情况相同，两个线程按照不同的顺序来获取两个锁，因此就可能产生死锁。
   在LeftRightDeadlock或transferMoney中，要查找死锁是比较简单的，只需要找出那些需要获取两个锁的方法。然而要在Taxi和Dispatcher中查找死锁则比较困难：如果在持有锁的情况下调用某个外部方法，那么就需要警惕死锁。
   如果在持有锁时调用某个外部方法，那么将出现活跃性问题。在这个外部方法中可能会获取其他锁（这可能会产生死锁），或者阻塞时间过长，导致其他线程无法及时获得当前被持有的锁。

10.1.4 开放调用

   当然，Taxi和Dispatcher并不知道它们将要陷入死锁，况且它们本来就不应该知道。方法调用相当于一种抽象屏障，因而你无须了解在被调用方法中所执行的操作。但也正是由于不知道在被调用方法中执行的操作，因此在持有锁的时候对调用某个外部方法将难以进行分析，从而可能出现死锁。
   如果在调用某个方法时不需要持有锁，那么这种调用被称为开放调用（Open Call）[CPJ 2.4.1.3]。依赖于开放调用的类通常能表现出更好的行为，并且与那些在调用方法时需要持有锁的类相比，也更易于编写。这种通过开放调用来避免死锁的方法，类似于采用封装机制来提供线程安全的方法：虽然在没有封装的情况下也能确保构建线程安全的程序，但对一个使用了封装的程序进行线程安全分析，要比分析没有使用封装的程序容易得多。同理，分析一个完全依赖于开放调用的程序的活跃性，要比分析那些不依赖开放调用的程序的活跃性简单。通过尽可能地使用开放调用，将更易于找出那些需要获取多个锁的代码路径，因此也就更容易确保采用一致的顺序来获得锁。【这些对开放调用以及锁顺序的依赖，反映了在构造同步对象（而不是对已构造好的对象进行同步）过程中存在的复杂性。】
   可以很容易地将程序清单10-5中的Taxi和Dispatcher修改为使用开放调用，从而消除发生死锁的风险。这需要使同步代码块仅被用于保护那些涉及共享状态的操作，如程序清单10-6所示。通常，如果只是为了语法紧凑或简单性（而不是因为整个方法必须通过一个锁来保护）而使用同步方法（而不是同步代码块），那么就会导致程序清单10-5中的问题。（此外，收缩同步代码块的保护范围还可以提高可伸缩性，在11.4.1节中给出了如何确定同步代码块大小的方法。）
   程序清单10-6　通过公开调用来避免在相互协作的对象之间产生死锁

@ThreadSafe
class Taxi {
   
  @GuardedBy("this") private Point location, destination;
  private final Dispatcher dispatcher;
  public synchronized Point getLocation() {
    return location; }
  public void setLocation(Point location) {
   
    boolean reachedDestination;
    synchronized (this) {
   
      this.location = location;
      reachedDestination = location.equals(destination);
    }
    if (reachedDestination) {
   
      dispatcher.notifyAvaileable(this);
    }
  }
  @ThreadSafe
  class Dispather {
   
    @GuardedBy("this") private final Set<Taxi> taxis;
    @GuardedBy("this") private final Set<Taxi> availableTaxis;
    public synchronized void notifyAvaileable(Taxi taxi) {
   
      availableTaxis.add(taxi);
    }
    public Image getImage() {
   
      Set<Taxi> copy;
      synchronized (this) {
   
        copy = new HashSet