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