课程咨询 :186 8716 1620      qq:2066486918

昆明Java培训 > 达内新闻 > Effective Java中避免过度同步
  • Effective Java中避免过度同步

    发布:昆明Java培训      来源:达内新闻      时间:2016-10-19

  • 昆明达内Java培训的老师这一期给大家讲Effective Java中避免过度同步。

    这里有一个辅助基础类

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

    }

    }

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

    昆明达内Java培训的老师提醒大家要点:就是外部调用函数,最好不要进入到同步区,简而言之同步区尽量就在内部进行操作,同步区尽可能少的工作,获得锁,处理数据,释放锁,都在内部完成。

    推荐文章

上一篇:java并发的Thread类中的方法

下一篇:Java培训:一个树型通用接口

最新开班日期  |  更多

Java--零基础全日制班

Java--零基础全日制班

开班日期:11/30

Java--零基础业余班

Java--零基础业余班

开班日期:11/30

Java--周末提升班

Java--周末提升班

开班日期:11/30

Java--零基础周末班

Java--零基础周末班

开班日期:11/30

  • 网址:http://km .java.tedu.cn      地址:昆明市官渡区春城路62号证券大厦附楼6楼
  • 课程培训电话:186 8716 1620      qq:2066486918    全国服务监督电话:400-827-0010
  • 服务邮箱 ts@tedu.cn
  • 2001-2016 达内国际公司(TARENA INTERNATIONAL,INC.) 版权所有 京ICP证08000853号-56