这里有一个辅助基础类
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
这个会造成死锁，要使用
让我们外部调用的内部集合避免上锁，而是建立一个快照，然后对快照进行上锁
要点：就是外部调用函数，最好不要进入到同步区，简而言之同步区尽量就在内部进行操作，同步区尽可能少的工作，获得锁，处理数据，释放锁，都在内部完成