Copy On Write Hash Map

来源：互联网发布：双色球数据统计中心编辑：程序博客网时间：2024/04/28 20:13

来源：http://www.xymyeah.com/269.html

我们在工作的过程中，经常遇到如下的需求：
用一个Map存放常用的Object，这个Map的并发读取的频率很高，而写入的频率很低，一般只在初始化、或重新装装载的时候写入。读写冲突虽然很少发生，不过一旦发生，Map的内部结构就可能乱掉，所以，我们不得不为Map加上同步锁。
我们可以采用Copy On Write的机制，来加强Map的读取速度。
Copy On Write是这样一种机制。当我们读取共享数据的时候，直接读取，不需要同步。当我们修改数据的时候，我们就把当前数据Copy一份副本，然后在这个副本上进行修改，完成之后，再用修改后的副本，替换掉原来的数据。这种方法就叫做Copy On Write。
Oracle等关系数据库的数据修改就采用Copy On Write的模式。Copy On Write模式对并发读取的支持很好，但是在并发修改的时候，会有版本冲突的问题。可能有多个线程同时修改同一份数据，那么就同时存在多个修改副本，这多个修改副本可能会相互覆盖，导致修改丢失。因此，Oracle等数据库通常会引入版本检查机制。即增加一个版本号字段，来检测是否存在并发修改。相似的版本控制机制存在于CVS、SVN等版本控制工具中。
在我们的Copy On Write Map中，我们只需要让新数据覆盖旧数据就可以了，因此不需要考虑版本控制的问题。这就大大简化了我们的实现。
基本思路就是让读和写操作分别在不同的Map上进行，每次写完之后，再把两个Map同步。代码如下：

Java代码  
/* 
 * Copy On Write Map 
 *  
 * Write is expensive. 
 * Read is fast as pure HashMap. 
 * 
 * Note: extra info is removed for free use 
 */  
import java.lang.Compiler;  
import java.util.Collection;  
import java.util.Map;  
import java.util.Set;  
import java.util.HashMap;  
import java.util.Collections;  
 public class ReadWriteMap implements Map {  
    protected volatile Map mapToRead = getNewMap();  
    // you can override it as new TreeMap();  
    protected Map getNewMap(){  
        return new HashMap();  
    }  
    // copy mapToWrite to mapToRead  
    protected Map copy(){  
        Map newMap = getNewMap();  
        newMap.putAll(mapToRead);  
        return newMap;  
    }  
   
    // read methods  
    public int size() {  
        return mapToRead.size();  
    }  
    public boolean isEmpty() {  
        return mapToRead.isEmpty();  
    }  
   
    public boolean containsKey(Object key) {  
        return mapToRead.containsKey(key);  
    }  
   
    public boolean containsValue(Object value) {  
        return mapToRead.containsValue(value);  
    }  
   
    public Collection values() {  
        return mapToRead.values();  
    }  
   
    public Set entrySet() {  
        return mapToRead.entrySet();  
    }  
   
    public Set keySet() {  
        return mapToRead.keySet();  
    }  
   
    public Object get(Object key) {  
        return mapToRead.get(key);  
    }  
   
    // write methods  
    public synchronized void clear() {  
        mapToRead = getNewMap();  
    }  
   
    public synchronized Object remove(Object key) {  
        Map map = copy();  
        Object o = map.remove(key);  
        mapToRead = map;  
        return o;  
    }  
   
    public synchronized Object put(Object key, Object value) {  
        Map map = copy();   
        Object o = map.put(key, value);  
        mapToRead = map;  
        return o;  
    }  
   
    public synchronized void putAll(Map t) {  
        Map map = copy();   
        map.putAll(t);  
        mapToRead = map;  
    }  
}  

这个Map读取的时候，和普通的HashMap一样快。

写的时候，先把内部Map复制一份，然后在这个备份上进行修改，改完之后，再让内部Map等于这个修改后的Map。这个方法是同步保护的，避免了同时写操作。可见，写的时候，开销相当大。尽量使用 putAll() method。

http://www.xymyeah.com/269.html