你的位置:首页 > Java教程

[Java教程]【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

这个会造成死锁,要使用

 

 

让我们外部调用的内部集合避免上锁,而是建立一个快照,然后对快照进行上锁

要点:就是外部调用函数,最好不要进入到同步区,简而言之同步区尽量就在内部进行操作,同步区尽可能少的工作,获得锁,处理数据,释放锁,都在内部完成