对象缓冲池－－采用最近最久未使用策略(LRUCache )管理对象,同时带有事件监听功能[改正版]

1.LRUCacheWithListener :逻辑在这里实现
对象缓冲池－－－采用最近最久未使用策略管理对象,同时带有事件监听功能
工作原理:
采用集合框架(java.connection包)来实现最近最久未使用对象池
首先构造对象池、设置池的大小
放置对象到池中，保存时候，池的指针指向该对象，以表明该对象最近最短被使用过
当把新的对象放入到池中时候，池已经满，那把删除最久没有被使用的对象，然后放入对象
当从池中读取对象时候，根据条件从池中获得对象；然后把池的指针指向该取出的对象，以表明该对象最近最短被使用过
当池中有对象被清除时候（当成垃圾清除），会触发相关事件
当池被清空时候，会出发相关事件
这个类参考了org.apache.tomcat.util.collections.LRUCache的实现细节。
当然原代码采用Hashtable来存储池的对象列表，这里采用另外的存储方式－－－HashMap来存储
org.apache.tomcat.util.collections.LRUCache
文件位置:jakarta-tomcat-5.5.6\jakarta-tomcat-connectors\util

import java.util.*;

public class LRUCacheWithListener {

/**
* 池对象的包裹类，这样便于相关处理
* **/
class CacheNode {
CacheNode prev;
CacheNode next;
Abandon value;
Object key;
public CacheNode() {
}
}

/**
* 对象池大小
**/
private int cacheSize;
/**
* 对象列表、当然可以采用泛型编程，这样就实现自动装箱、解箱(boxing/unboxing)
* **/
private HashMap nodes;

/**
* 对象池当前对象数
* **/
private int currentSize;
/**
* 第一个节点
* **/
private CacheNode first;
/***
* 最后一个节点
* **/
private CacheNode last;
/**
* 对象锁
* 实际上下面也就几个地方使用了该锁，可以用同步方法来取代调使用这个对象锁
* **/
private static int DEFAULT_SIZE = 10;
public LRUCacheWithListener() {
this(DEFAULT_SIZE);
}

public LRUCacheWithListener(int poolSize) {
cacheSize = poolSize;
currentSize = 0;
first = null; //
last = null; //
nodes = new HashMap(poolSize);
}

/**
* 读取一个对象
* ***/
public synchronized Object get(Object key) {
CacheNode node = (CacheNode) nodes.get(key);
if (node != null) {
moveToHead(node);
return node.value;
} else {
return null;
}

}

/**
* 把指定对象移动到链表的头部
* */
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;
}
}

/**
* 删除池中指定对象
* **/
public synchronized 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 synchronized void put(Object key, Abandon value) {

CacheNode node = (CacheNode) nodes.get(key);
if (node == null) {
//池满，删除最久没有使用的对象
if (currentSize >= cacheSize) {
if (last != null) {
nodes.remove(last.key);
}
removeLast();
}
//池没有满，直接把对象放入池中
else {
currentSize++;
}
node = getANewCacheNode();
}
node.value = value;
node.key = key;
// 把放入池的这个对象移动到链表的头部，表示最近最短被使用过
moveToHead(node);
nodes.put(key, node);

}

/**清空池中对象
* **/
public synchronized void clear() {
// if (first != null) {
// Iterator i = nodes.values().iterator();
// //触发事件，该池已经被清空
// CacheNode n;
// while (i.hasNext()) {
// n = (CacheNode) (i.next());
// n.value.poolClear();
// }
// }
while(!nodes.isEmpty()){
//add by jeff
if (last != null) {
nodes.remove(last.key);
}
removeLast(); //从池中将对象一个个移除
}
first = null;
last = null;

}

/***
* 获得一个新的包裹对象
* **/
private CacheNode getANewCacheNode() {
CacheNode node = new CacheNode();
return node;
}

/**
* 删除池中最久没有使用的对象
* **/
private void removeLast() {
if (last != null) {
//对象从池中被抛弃，触发事件
last.value.onAbandon();
if (last.prev != null) {
last.prev.next = null;
} else {
first = null;
}
last = last.prev;
}

}
}

2.Abandon :定义对象被抛弃和池被清空的事件接口

public interface Abandon {
public void onAbandon();
}
3.CacheNodeWithListener 测试类

public class CacheNodeWithListener implements Abandon {
int id;
public CacheNodeWithListener() {

}

public CacheNodeWithListener(int i) {
id = i;
}

/**
* 当对象被池所抛弃时候，进行相关处理
* ***/
public void onAbandon() {
System.out.println(this +"---onAbandon()");
}

public String toString() {
return "id=" + id;
}

static public void main(String[] s) {
LRUCacheWithListener pool = new LRUCacheWithListener(3); //LRUCacheWithListener(int poolSize) 对象池大小
int i;
for (i = 1; i <= 5; i++) {
pool.put("obj" + i, new CacheNodeWithListener(i));
System.out.println("obj--"+i);
}
System.out.println("obj"+4+":"+pool.get("obj"+4));
pool.clear();//把 《对象池全清空》，poolSize有多大清多少
//检查pool里的对象是否全清掉
for (i = 1; i <= 5; i++) {
System.out.println("obj"+i+":"+pool.get("obj"+i));
}

}
}

4.结论:打印结果

当poolSize为3，而有5个对象需要加入，打印结果如下：
obj--1
obj--2
obj--3
id=1---onAbandon()
obj--4
id=2---onAbandon()
obj--5
obj4:id=4
id=3---onAbandon()
id=5---onAbandon()
id=4---onAbandon()
obj1:null
obj2:null
obj3:null
obj4:null
obj5:null

解析：先放入3个对象，第四个对象加入时抛弃最先加入的对象1
第五个对象加入时抛弃最二先加入的对象2，最后clear就把
内存中的3，4，5清掉