LRU

摘要: java LRU

在Java中为了提高系统的效率，最常用的就是加入缓存机制，但是缓存也不可能被无限的放入数据，如果缓存的命中率太低，对于系统而言，也是一种负担。

什么是LRU算法？ LRU是Least Recently Used的缩写，即最少使用页面置换算法。

MySql中的LRU实现：

package com.mysql.jdbc.util;

import java.util.LinkedHashMap;
import java.util.Map.Entry;

/**
* @author Mark Matthews
* @version $Id$
*/
public class LRUCache extends LinkedHashMap<Object, Object> {
private static final long serialVersionUID = 1L;
protected int maxElements;

public LRUCache(int maxSize) {
super(maxSize, 0.75F, true);
this.maxElements = maxSize;
}

/*
* (non-Javadoc)
*
* @see java.util.LinkedHashMap#removeEldestEntry(java.util.Map.Entry)
*/
@Override
protected boolean removeEldestEntry(Entry<Object, Object> eldest) {
return (size() > this.maxElements);
}
}

tomcat6的实现：

package org.apache.tomcat.util.collections;

import java.util.Hashtable;

/**
* This class implements a Generic LRU Cache
*
*
* @author Ignacio J. Ortega
*
* @deprecated
*/

public class LRUCache
{
class CacheNode
{

CacheNode prev;
CacheNode next;
Object value;
Object key;

CacheNode()
{
}
}

public LRUCache(int i)
{
currentSize = 0;
cacheSize = i;
nodes = new Hashtable(i);
}

public Object get(Object key)
{
CacheNode node = (CacheNode)nodes.get(key);
if(node != null)
{
moveToHead(node);
return node.value;
}
else
{
return null;
}
}

public void put(Object key, Object value)
{
CacheNode node = (CacheNode)nodes.get(key);
if(node == null)
{
if(currentSize >= cacheSize)
{
if(last != null)
nodes.remove(last.key);
removeLast();
}
else
{
currentSize++;
}
node = new CacheNode();
}
node.value = value;
node.key = key;
moveToHead(node);
nodes.put(key, node);
}

public Object remove(Object key) {
CacheNode node = (CacheNode)nodes.get(key);
if (node != null) {
if (node.prev != null) {
node.prev.next = node.next;
}
if (node.next != null) {
node.next.prev = node.prev;
}
if (last == node)
last = node.prev;
if (first == node)
first = node.next;
}
return node;
}

public void clear()
{
first = null;
last = null;
}

private void removeLast()
{
if(last != null)
{
if(last.prev != null)
last.prev.next = null;
else
first = null;
last = last.prev;
}
}

private void moveToHead(CacheNode node)
{
if(node == first)
return;
if(node.prev != null)
node.prev.next = node.next;
if(node.next != null)
node.next.prev = node.prev;
if(last == node)
last = node.prev;
if(first != null)
{
node.next = first;
first.prev = node;
}
first = node;
node.prev = null;
if(last == null)
last = first;
}

private int cacheSize;
private Hashtable nodes;
private int currentSize;
private CacheNode first;
private CacheNode last;
}

tomcat7的实现：

package org.apache.tomcat.util.collections;

import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap;

public final class ConcurrentCache<K,V> {

private final int size;

private final Map<K,V> eden;

private final Map<K,V> longterm;

public ConcurrentCache(int size) {
this.size = size;
this.eden = new ConcurrentHashMap<K,V>(size);
this.longterm = new WeakHashMap<K,V>(size);
}

public V get(K k) {
V v = this.eden.get(k);
if (v == null) {
synchronized (longterm) {
v = this.longterm.get(k);
}
if (v != null) {
this.eden.put(k, v);
}
}
return v;
}

public void put(K k, V v) {
if (this.eden.size() >= size) {
synchronized (longterm) {
this.longterm.putAll(this.eden);
}
this.eden.clear();
}
this.eden.put(k, v);
}
}