Copy On Write Hash Map

咱们在工做的过程当中，常常遇到以下的需求： 
用一个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代码 

1. /*
2. * Copy On Write Map
3. *
4. * Write is expensive.
5. * Read is fast as pure HashMap.
6. *
7. * Note: extra info is removed for free use
8. */
9. import java.lang.Compiler;
10. import java.util.Collection;
11. import java.util.Map;
12. import java.util.Set;
13. import java.util.HashMap;
14. import java.util.Collections;
15. public class ReadWriteMap implements Map {
16. protected volatile Map mapToRead = getNewMap();
17. // you can override it as new TreeMap();
18. protected Map getNewMap(){
19. return new HashMap();
20. }
21. // copy mapToWrite to mapToRead
22. protected Map copy(){
23. Map newMap = getNewMap();
24. newMap.putAll(mapToRead);
25. return newMap;
26. }
28. // read methods
29. public int size() {
30. return mapToRead.size();
31. }
32. public boolean isEmpty() {
33. return mapToRead.isEmpty();
34. }
36. public boolean containsKey(Object key) {
37. return mapToRead.containsKey(key);
38. }
40. public boolean containsValue(Object value) {
41. return mapToRead.containsValue(value);
42. }
44. public Collection values() {
45. return mapToRead.values();
46. }
48. public Set entrySet() {
49. return mapToRead.entrySet();
50. }
52. public Set keySet() {
53. return mapToRead.keySet();
54. }
56. public Object get(Object key) {
57. return mapToRead.get(key);
58. }
60. // write methods
61. public synchronized void clear() {
62. mapToRead = getNewMap();
63. }
65. public synchronized Object remove(Object key) {
66. Map map = copy();
67. Object o = map.remove(key);
68. mapToRead = map;
69. return o;
70. }
72. public synchronized Object put(Object key, Object value) {
73. Map map = copy();
74. Object o = map.put(key, value);
75. mapToRead = map;
76. return o;
77. }
79. public synchronized void putAll(Map t) {
80. Map map = copy();
81. map.putAll(t);
82. mapToRead = map;
83. }
84. }

这个Map读取的时候，和普通的HashMap同样快。 万艾可：www.weigecheng.com
写的时候，先把内部Map复制一份，而后在这个备份上进行修改，改完以后，再让内部Map等于这个修改后的Map。这个方法是同步保护的，避免了同时写操做。可见，写的时候，开销至关大。尽可能使用 putAll() method。