google的ConcurrentLinkedHashmap源代码解析

原文地址：[url]http://janeky.iteye.com/blog/1534352[/url]
简述
ConcurrentLinkedHashMap 是google团队提供的一个容器。它有什么用呢？其实它本身是对

ConcurrentHashMap的封装，可以用来实现一个基于LRU策略的缓存。详细介绍可以参见

http://code.google.com/p/concurrentlinkedhashmap

使用范例
Java代码 收藏代码
public static void main(String[] args) {
ConcurrentLinkedHashMap<Integer, Integer> map = new
<span style="white-space: pre;"> </span>ConcurrentLinkedHashMap.Builder<Integer,Integer>().maximumWeightedCapacity(2).
Java代码 收藏代码
weigher(Weighers.singleton()).build();
Java代码 收藏代码
map.put(1, 1);
map.put(2, 2);
map.put(3, 3);
System.out.println(map.get(1));//null 已经失效了
System.out.println(map.get(2));

ConcurrentLinkedHashMap 的构造函数比较特殊，它采用了Builder（构造器，GOF模式之一)。

它本身也是实现了ConcurrentMap接口的，所以使用起来跟ConcurrentHashMap一样。我们先put

进去三个元素，然后获取第一个元素，果然是null，因为基于LRU（最近使用)算法，key=1的节

点已经失效了。

源代码解析
先来看看它的整体框架


它本质是额外维护了一个双向链表，每次读和写都要改变相应节点的位置，将其移至队列头。

什么时候判断容易已经满了，是根据weight。每个元素都有一个weight，每增加一个元素，weight累计。当达到最大值的时候，就需要剔除最少操作的那个元素了，并且触发相关的事件。

我们先来看put函数

Java代码 收藏代码
V put(K key, V value, boolean onlyIfAbsent) {
checkNotNull(value);

final int weight = weigher.weightOf(key, value);//计算weight
final WeightedValue<V> weightedValue = new WeightedValue<V>(value, weight);
final Node node = new Node(key, weightedValue);//对数据进行包装，准备存入

ConcurrentHashMap

for (;;) {
final Node prior = data.putIfAbsent(node.key, node);
if (prior == null) {//这个key之前没有值
afterCompletion(new AddTask(node, weight));//更新后续操作
return null;
} else if (onlyIfAbsent) {
afterCompletion(new ReadTask(prior));
return prior.getValue();
}

AddTask 是判断是否容量满了，需要剔除其他元素
Java代码 收藏代码
final class AddTask extends AbstractTask {
final Node node;
final int weight;

@Override
@GuardedBy("evictionLock")
public void run() {
weightedSize += weight;

// ignore out-of-order write operations
if (node.get().isAlive()) {
evictionDeque.add(node);
evict();//是否移除失效的
}
}

}

void evict() {

while (hasOverflowed()) {
Node node = evictionDeque.poll();

// If weighted values are used, then the pending operations will adjust
// the size to reflect the correct weight
if (node == null) {
return;
}

// Notify the listener only if the entry was evicted
if (data.remove(node.key, node)) {//移除失效的
pendingNotifications.add(node);
}

node.makeDead();
}
}

get函数更简单一点，只是将这个key节点移至队列头
Java代码 收藏代码
public V get(Object key) {
final Node node = data.get(key);
if (node == null) {
return null;
}
afterCompletion(new ReadTask(node));
return node.getValue();
}

性能比较 vs ConcurrentHashMap
不用说了，肯定是ConcurrentHashMap要好一点了，因为本文的主角还要维护一个操作队列嘛：）
不过性能上不是差很多，见下图。


总结：
利用ConcurrentLinkedHashMap来做基于LRU的缓存，还是值得推荐的。我们可以定义它的容器大小，基于LRU，就可以保证较高的命中率了。

参考资料：
http://code.google.com/p/concurrentlinkedhashmap