java并发编程之过度同步

            过度同步可能造成性能减低、死锁，甚至不确定的问题。

    在一个被同步的区域内部，不要调用被设计成被复写(覆盖)的方法。从包含该同步区域的类的角度来看，这样的方法是外来的。这个类不知道该方法会做些什么事情，也无法控制它。从同步块中调用它会导致异、死锁或者数据损坏。

    示例：下面的代码采用了观察者模式，当状态改变时，在同步块中调用了外来方法---观察者方法(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);
		}
	}

    注意，为了避免死锁和数据破坏，千万不要从同步区域内部调用外来方法。或者说，要尽量限制同步区域的工作量。