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);
		}
	}

    注意，爲了避免死鎖和數據破壞，千萬不要從同步區域內部調用外來方法。或者說，要儘量限制同步區域的工作量。