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

}

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

}
}