过度同步可能造成性能减低、死锁,甚至不确定的问题。
在一个被同步的区域内部,不要调用被设计成被复写(覆盖)的方法。从包含该同步区域的类的角度来看,这样的方法是外来的。这个类不知道该方法会做些什么事情,也无法控制它。从同步块中调用它会导致异、死锁或者数据损坏。
示例:下面的代码采用了观察者模式,当状态改变时,在同步块中调用了外来方法---观察者方法(added()),这个方法会被具体每个观察者复写,这样就无法控制该方法的行为
public class ObservableSet<E> extends ForwardingSet<E>
{
//观察者列表
private final List<SetObserver<E>> observers = new ArrayList<SetObserver<E>>();
public ObservableSet(Set<E> set)
{
super(set);
}
/**
* 添加观察者
* @param observer
*/
public void addObserver(SetObserver<E> observer)
{
synchronized(observers)
{
observers.add(observer);
}
}
/**
* 删除某个观察者
* @param observer
* @return
*/
public boolean removeObserver(SetObserver<E> observer)
{
synchronized(observers)
{
return observers.remove(observer);
}
}
/**
* 通知观察者方法
* @param element
*/
private void notifyElementAdded(E element)
{
synchronized(observers)
{
for(SetObserver<E> observer: observers)
{
observer.added(this, element);
}
}
}
/**
* 被观察者状态发生变化时,通知观察者
*/
public boolean add(E element)
{
boolean added = super.add(element);
if(added)
{
notifyElementAdded(element);
}
return added;
}
public boolean addAll(Collection<? extends E> c)
{
boolean result = false;
for(E element : c)
{
result |= add(element);
}
return result;
}
}
这个测试程序注册了一个观察者,这个观察者复写了added()方法,而且赋予的新的行为是当遍历的元素为23时,删除该观察者本身,这样造成的问题是,当我们正在遍历列表observers时,将一个元素从其中删除,从而造成非法操作并抛异常。
public class Test
{
public static void main(String[] args)
{
ObservableSet<Integer> set = new ObservableSet<Integer>(new HashSet<Integer>());
/**
* 正在遍历列表的过程中,将一个元素从列表删除,这是非法的
*/
set.addObserver(new SetObserver<Integer>()
{
public void added(ObservableSet<Integer> s, Integer e)
{
System.out.println(e);
if(23 == e)
{
s.removeObserver(this);
}
}
});
for(int i = 0; i < 100; i++)
{
set.add(i);
}
}
}
修改的方法也很简单,将外来方法的调用移除同步的代码块:
/**
* 通知观察者方法
* @param element
*/
private void notifyElementAdded(E element)
{
List<SetObserver<E>> snapshot = null;
synchronized(observers)
{
snapshot = new ArrayList<SetObserver<E>>(observers);
}
for(SetObserver<E> observer: snapshot)
{
observer.added(this, element);
}
}
注意,为了避免死锁和数据破坏,千万不要从同步区域内部调用外来方法。或者说,要尽量限制同步区域的工作量。