昆明java培训
达内昆明广州春城路

18487146383

热门课程

Effective Java中避免过度同步

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

昆明达内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培训:一个树型通用接口

Effective java的创建和销毁对象

昆明达内Java培训学费多少?

LinkedIn服务:三人行,必有我师【达内java培训】

Java培训:7月排行榜Go创新高Java稳第一

选择城市和中心
贵州省

广西省

海南省

台湾