Java并发编程实战协作对象间的死锁与开放调用

某些获取多个锁的操作并不像在LeftRightDeadlock或transferMoney中那么明显&＃xff0c;这两个锁并不一定必须在同一个方法中被获取。下面两个相互协作的类&＃xff0c;在出租车调度系统中可能会找到它们。Taxi代表一个出租车对象&＃xff0c;包含位置和目的地两个属性&＃xff0c;Dispatcher代表一个出租车车队。

public class Taxi {private final Dispatcher dispatcher;private Point location, destination;public Taxi(Dispatcher dispatcher) {this.dispatcher &＃61; dispatcher;}public synchronized Point getLocation() {return location;}public synchronized void setLocation(Point location){this.location &＃61; location;if(location.equals(destination)){dispatcher.notifyAvaliable(this);}}
}public class Dispatcher {private final Set taxis;private final Set avaliableTaxis;public Dispatcher() {taxis &＃61; new HashSet();avaliableTaxis &＃61; new HashSet();}public synchronized void notifyAvaliable(Taxi taxi) {avaliableTaxis.add(taxi);}public synchronized Image getImage() {Image image &＃61; new Image();for (Taxi t : taxis) {image.drawMarker(t.getLocation());}return image;}
}

尽管没有任何方法会显式地获取两个锁&＃xff0c;但setLocation和getImage等方法的调用者都会获得两个锁。如果一个线程在收到GPS接收器的更新事件时调用setLocation&＃xff0c;那么它将首先更新出租车的位置&＃xff0c;然后判断它是否到达了目的地。如果已经到达&＃xff0c;它会通知Dispatcher&＃xff1a;它需要一个新的目的地。因为setLocation和notifyAvailable都是同步方法&＃xff0c;因此调用setLocation的线程将首先获取Taxi的锁&＃xff0c;然后获取Dispatcher的锁。同样&＃xff0c;调用getImage的线程将首先获取Dispatcher的锁&＃xff0c;然后再获取每一个Taxi的锁&＃xff08;每次获取一个&＃xff09;。这与LeftRightDeadlock中的情况相同&＃xff0c;两个线程按照不同的顺序来获取两个锁&＃xff0c;因此就可能产生死锁。

在LeftRightDeadlock或transferMoney中&＃xff0c;要查找死锁是比较简单的&＃xff0c;只需要找出那些需要获取两个锁的方法。然而要在Taxi和Dispatcher中查找死锁则比较困难&＃xff1a;如果在持有锁的情况下调用某个外部方法&＃xff0c;那么就需要警惕死锁。

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

Taxi和Dispatcher并不知道它们将要陷入死锁&＃xff0c;况且它们本来就不应该知道。方法调用相当于一种抽象屏障&＃xff0c;因而你无须了解在被调用方法中所执行的操作。但也正是由于不知道在被调用方法中执行的操作&＃xff0c;因此在持有锁的时候对调用某个外部方法将难以进行分析&＃xff0c;从而可能出现死锁。

如果在调用某个方法时不需要持有锁&＃xff0c;那么这种调用被称为开放调用。依赖于开放调用的类通常能表现出更好的行为&＃xff0c;并且在与那些在调用方法时需要持有锁的类相比&＃xff0c;也更易于编写。通过尽可能地使用开放调用&＃xff0c;将更易于找出那些需要获取多个锁的代码路径&＃xff0c;因此也就更容易确保采用一致的顺序来获得锁。

开放调用需要使代码块仅被用于保护那些涉及共享状态的操作&＃xff0c;如下程序所示&＃xff0c;如果只是为了语法紧凑或简单性&＃xff08;而不是因为整个方法必须通过一个锁来保护&＃xff09;而使用同步方法&＃xff08;而不是同步代码块&＃xff09;&＃xff1a;

&＃64;ThreadSafe
class Taxi {&＃64;GuardedBy("this")private Point location;&＃64;GuardedBy("this")private Point destination;private final Dispatcher dispatcher;public Taxi(Dispatcher dispatcher) {this.dispatcher &＃61; dispatcher;}public synchronized Point getLocation() {return location;}public synchronized void setLocation(Point location) {boolean reachedDestination;synchronized (this) {this.location &＃61; location;reachedDestination &＃61; location.equals(destination);}if (reachedDestination) {dispatcher.notifyAvailable(this);}}public synchronized Point getDestination() {return destination;}public synchronized void setDestination(Point destination) {this.destination &＃61; destination;}
}&＃64;ThreadSafe
class Dispatcher {&＃64;GuardedBy("this")private final Set taxis;&＃64;GuardedBy("this")private final Set availableTaxis;public Dispatcher() {taxis &＃61; new HashSet();availableTaxis &＃61; new HashSet();}public synchronized void notifyAvailable(Taxi taxi) {availableTaxis.add(taxi);}public Image getImage() {Set copy;synchronized (this) {copy &＃61; new HashSet(taxis);}Image image &＃61; new Image();for (Taxi t : copy)image.drawMarker(t.getLocation());return image;}
}class Image {public void drawMarker(Point p) {}
}


有时候&＃xff0c;在重新编写同步代码块以使用开发调用时会产生意想不到的结果&＃xff0c;因为这会使得某个原子操作变为非原子操作。在许多情况下&＃xff0c;使某个操作失去原子性是可以接受的。例如&＃xff0c;对于两个操作&＃xff1a;更新出租车位置以及通知调度程序这辆出租车已准备好出发去一个新的目的地&＃xff0c;这两个操作并不需要实现为一个原子操作。在其他情况下&＃xff0c;虽然去掉原子性可能会出现一些值得注意的结果&＃xff0c;但这种语义变化仍然是可以接受的。在容易产生死锁的版本中&＃xff0c;getImage会生成某个时刻下的整个车队位置的完整快照&＃xff0c;而在重新改写的版本中&＃xff0c;getImage将获得每辆出租车不同时刻的位置。

然而&＃xff0c;在某些情况下&＃xff0c;丢失原子性会引发错误&＃xff0c;此时需要通过另一种技术来实现原子性。例如&＃xff0c;在构建一个并发对象时&＃xff0c;使得每次只有单个线程执行使用了开放调用的代码路径。例如&＃xff0c;在关闭某个服务时&＃xff0c;你可能希望所有正在运行的操作执行完成以后&＃xff0c;再释放这些服务占用的资源。如果在等待操作完成的同时持有该服务的锁&＃xff0c;那么将很容易导致死锁&＃xff0c;但如果在服务关闭之前就释放服务的锁&＃xff0c;则可能导致其他线程开始新的操作。这个问题的解决方法是&＃xff0c;在将服务的状态更新为”关闭“之前一直持有锁&＃xff0c;这样其他想要开始新的操作的线程&＃xff0c;包括想关闭该服务的其他线程&＃xff0c;会发现服务已经不可用&＃xff0c;因此也就不会试图开始新的操作。然后&＃xff0c;你可以等待关闭操作结束&＃xff0c;并且知道当开放调用完成后&＃xff0c;只有执行关闭操作的线程才能访问该服务的状态。因此&＃xff0c;这项技术依赖于构造的一些协议&＃xff08;而不是通过加锁&＃xff09;来防止其他线程进入代码的临界区。

Java并发编程实战pdf及案例源码下载&＃xff1a;
http://download.csdn.net/detail/xunzaosiyecao/9851028

作者&＃xff1a;jiankunking 出处&＃xff1a;http://blog.csdn.net/jiankunking