关于FastHashMap...

今天在开发过程中碰到了一处使用了beanutil中的fasthashmap.在网上查询对比了两者的区别。总算是弄明白了。

 

 发现在缓存对象的时候基本上都使用commons的FastHashMap.

google一下发现HashMap vs FastHashMap的文章,感觉很奇怪.

下班后download下来FastHashMap的代码看了一下

commons中FastHashMap类的doc写道:

java.util.HashMap类的一种自定义实现,以应付多线程环境中大量只读方法而非改变改变结构的方法的访问.

当以fast模式运行时,只读方法不是线程安全的,而写操作以下面的步骤进行操作

1 克隆当前的数据集合

2 在克隆对象上进行修改

3 用修改过的克隆对象替换原对象

当FastHashMap被初始化的时候,默认是以slow模式运行.

另外该文档强烈建议:如果是以单线程的模式访问hashmap,建议直接使用hashmap而非FastHashMap,以获得

最大的性能.

 

接下来我们看FastHashMap的代码实现

首先是类定义,类构造器和类属性

Java代码

1. public class FastHashMap extends HashMap {   
2.     protected HashMap map = null;   
3.     protected boolean fast = false;       
4.     public FastHashMap() {   
5.             super();   
6.             this.map = new HashMap();   
7.         }   
8. }    

public class FastHashMap extends HashMap {
	protected HashMap map = null;
	protected boolean fast = false;    
	public FastHashMap() {
        	super();
        	this.map = new HashMap();
    	}
}  

 

 FastHashMap继承于HashMap,存储由HashMap实现的,通过fast来设置是否是以快速模式执行.可以初步认为FashHashMap是HashMap的一个代理.

先看get操作

Java代码

1. public Object get(Object key) {   
2.         if (fast) {   
3.             return (map.get(key));   
4.         } else {   
5.             synchronized (map) {   
6.                 return (map.get(key));   
7.             }   
8.         }   
9.     }  

public Object get(Object key) {
        if (fast) {
            return (map.get(key));
        } else {
            synchronized (map) {
                return (map.get(key));
            }
        }
    }

 

默认情况下,对map进行了同步,get方法的实现还是线程安全的.

这是之所以比HashMap类put数据速度慢的原因.

再看put操作

Java代码

1. public Object put(Object key, Object value) {   
2.         if (fast) {   
3.             synchronized (this) {   
4.                 HashMap temp = (HashMap) map.clone();   
5.                 Object result = temp.put(key, value);   
6.                 map = temp;   
7.                 return (result);   
8.             }   
9.         } else {   
10.             synchronized (map) {   
11.                 return (map.put(key, value));   
12.             }   
13.         }   
14.     }  

public Object put(Object key, Object value) {
        if (fast) {
            synchronized (this) {
                HashMap temp = (HashMap) map.clone();
                Object result = temp.put(key, value);
                map = temp;
                return (result);
            }
        } else {
            synchronized (map) {
                return (map.put(key, value));
            }
        }
    }

 注意到如果是fast模式,map的引用发生了改变,因此这一刻锁定了this,锁定了当前FastHashMap类的实例.这在大量读写方法并发的情况下,执行效率是很低的.

默认情况对map进行了同步,也是线程安全的.

 

因此总结

FastHashMap在设定fast=true的情况下才是以fast模式运行的

其次

FastHashMap是为了多线程的情况使用的,而hashmap应用于当线程情况.两者根本就不处于同一个应用场景.因此比较也是无意义的.

其次FastHashMap的put方法使用的是整个对象的实例锁,如果写进程很多很容易堵塞,这一点在fasthashmap的官方文档中已经很清楚写道:

写道

* <p>A customized implementation of <code>java.util.HashMap</code> designed
* to operate in a multithreaded environment where the large majority of
* method calls are read-only, instead of structural changes.