【Effective Java】12、避免过度同步
这里有一个辅助基础类
package cn.xf.cp.ch02.item16; import java.util.Collection; import java.util.Iterator; import java.util.Set; public class ForwardingSet<E> implements Set<E> { /** * 这个类作为转发类，内部通过复合的方式把set作为一个组件 */ private final Set<E> s; public ForwardingSet(Set<E> s) { this.s = s; } @Override public int size() { return s.size(); } @Override public boolean isEmpty() { return s.isEmpty(); } @Override public boolean contains(Object o) { return s.contains(o); } @Override public Iterator<E> iterator() { return s.iterator(); } @Override public Object[] toArray() { return s.toArray(); } @Override public <T> T[] toArray(T[] a) { return s.toArray(a); } @Override public boolean add(E e) { return s.add(e); } @Override public boolean remove(Object o) { return s.remove(o); } @Override public boolean containsAll(Collection<?> c) { return s.containsAll(c); } @Override public boolean addAll(Collection<? extends E> c) { return s.addAll(c); } @Override public boolean retainAll(Collection<?> c) { return s.retainAll(c); } @Override public boolean removeAll(Collection<?> c) { return s.removeAll(c); } @Override public void clear() { s.clear(); } }
然后使用一个类使这个类可以被观察者注册
package cn.xf.cp.ch02.item67; import java.util.ArrayList; import java.util.Collection; import java.util.List; import java.util.Set; import cn.xf.cp.ch02.item16.ForwardingSet; public class ObservableSet<E> extends ForwardingSet<E> { public ObservableSet(Set<E> s) { super(s); } private final List<SetObserver<E>> observers = new ArrayList<SetObserver<E>>(); public void addObserver(SetObserver<E> observer) { synchronized (observers) { observers.add(observer); } } public boolean removeObserver(SetObserver<E> observer) { synchronized (observers) { return observers.remove(observer); } } // This method is the culprit private void notifyElementAdded(E element) { synchronized (observers) { for (SetObserver<E> observer : observers) observer.added(this, element); } } private void notifyElementAdded2(E element) { List<SetObserver<E>> snapshot = null; synchronized (observers) { //这里拍一个快照,这样我们遍历的时候就不用对原来的集合进行上锁了 snapshot = new ArrayList<SetObserver<E>>(observers); } for (SetObserver<E> observer : snapshot) observer.added(this, element); } @Override public boolean add(E e) { //调用父类函数添加到集合中 boolean added = super.add(e); if(added) { //添加成功,观察者保存注册对象 notifyElementAdded(e); } return added; } @Override public boolean addAll(Collection<? extends E> c) { boolean result = false; for(E element : c) { //做或运算，只要有一个add添加成功，那么result就是true result |= add(element); } return result; } }
可以注意到，这个类中已经有一个地方有两个方法，这个后面会将
观察者：
package cn.xf.cp.ch02.item67; public interface SetObserver<E> { /** * 当一个元素添加到ObservableSet对象中的时候，调用 * @param set * @param element */ void added(ObservableSet<E> set, E element); }
测试：
package cn.xf.cp.ch02.item67; import java.util.HashSet; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Test { @org.junit.Test public void test() { //创建一个被观察的对象 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); } }); for (int i = 0; i < 100; i++) set.add(i); } @org.junit.Test public void test2() { 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 (e == 23) //到23，我们取消这个观察者，但是会爆出异常，因为在迭代遍历列表的时候我们自己修改了列表，这是非法的 s.removeObserver(this); } }); for (int i = 0; i < 100; i++) set.add(i); } /** * 那么如何取消观察者者呢？？？？ * 我们使用另外的一个线程在23的时候删除这个观察者 */ @org.junit.Test public void test3() { ObservableSet<Integer> set = new ObservableSet<Integer>(new HashSet<Integer>()); set.addObserver(new SetObserver<Integer>() { @Override public void added(final ObservableSet<Integer> set, Integer element) { System.out.println(element); //如果是23 if(element == 23) { //线程池，创建单个线程的线程池，如果当前线程在执行任务时突然中断，则会创建一个新的线程替代它继续执行任务 ExecutorService executor = Executors.newSingleThreadExecutor(); final SetObserver<Integer> observer = this; try { executor.submit(new Runnable() { @Override public void run() { //这里会死锁 set.removeObserver(observer); } }).get(); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } finally { executor.shutdown(); } } } }); for (int i = 0; i < 100; i++) set.add(i); } }
结果：
测试2
这里会抛出异常，为什么，理由已经在类中写了
测试3
这个会造成死锁，要使用
让我们外部调用的内部集合避免上锁，而是建立一个快照，然后对快照进行上锁
要点：就是外部调用函数，最好不要进入到同步区，简而言之同步区尽量就在内部进行操作，同步区尽可能少的工作，获得锁，处理数据，释放锁，都在内部完成
