Java CopyOnWriteArray

package concurrent;

import java.util.Arrays;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.locks.ReentrantLock;

/*
* @author: wjf
* @version: 2016年3月30日 上午9:51:17
*/

public class TestCopyOnWrite {

    public static void main(String[] args){
        /*具体 add 的代码，修改时复制，添加 修改元素时，先新建一个 array，修改完之后，将原来的array 指向新的array，
         *这样在添加元素的时候，旧的array一眼可以向外部提供 并发读的 服务，这是一种读写分离的思想，但是就是读的可能不是最新的数据
         *在实时性系统中并不适用，适用于读多写少的场景，比如黑名单机制，大多数情况下是读取黑名单，修改一般较少，
         * 可以使用类似思想实现任何的 copyOnWrite 容器
         *
         * public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
        }
         */

        CopyOnWriteArrayList<Integer> list=new CopyOnWriteArrayList<Integer>();
    }

}

自己实现 copyOnWriteMap

class CopyOnWriteMap<K,V> implements Map<K,V> ,Cloneable{
            private volatile Map<K,V> internalMap;
            public CopyOnWriteMap(){
                this.internalMap=new HashMap<K,V>();
            }
            @Override
            public V get(Object key) {
                // TODO Auto-generated method stub
                return internalMap.get(key);
            }
            @Override
            public V put(K key, V value) {
                // TODO Auto-generated method stub
                synchronized(this){
                    HashMap<K,V> newMap=new HashMap<K,V>(internalMap);
                    newMap.put(key, value);
                    this.internalMap=newMap;
                }
                return value;
            }
            @Override
            public V remove(Object key) {
                // TODO Auto-generated method stub
                synchronized(this){
                    HashMap<K,V> newMap=new HashMap<K,V>(internalMap);
                    V value=newMap.remove(key);
                    this.internalMap=newMap;
                    return value;
                }

            }
            @Override
            public void putAll(Map<? extends K, ? extends V> m) {
                // TODO Auto-generated method stub
                synchronized(this){
                    HashMap<K,V> newMap=new HashMap<K,V>(internalMap);
                     newMap.putAll(m);
                    this.internalMap=newMap;
                }

            }
        }