LRU是Least Recently Used,最近最少使用。
LRU缓存就是使用这种原理实现,简单的说就是缓存一定量的数据,当超过设定的阈值时就把一些过期的数据删除掉。
LRU思想
- 固定缓存大小,需要给缓存分配一个固定的大小。
- 每次读取缓存都会改变缓存的使用时间,将缓存的存在时间重新刷新。
- 需要在缓存满了后,将最近最久未使用的缓存删除,再添加最新的缓存。
Java实现
/**
* @author huangliuyu
* @description LRU 最近最久未使用
* @date 2019-05-10
*/
public class LRUCache {
private Node head;
private Node end;
//缓存存储上限
private int limit;
private HashMap<String, Node> hashMap;
public LRUCache(int limit){
this.limit=limit;
hashMap=new HashMap<String, Node>();
}
public String get(String key){
Node node=hashMap.get(key);
if(null==node){
return null;
}
this.refreshNode(node);
return node.value;
}
public void put(String key, String value){
Node node = hashMap.get(key);
//如果key不存在,插入key-value
if(null==node){
//临界值,清理最少使用节点
if(hashMap.size()>=limit){
String oldKey=this.removeNode(head);
hashMap.remove(oldKey);
}
node=new Node(key,value);
this.addNode(node);
hashMap.put(key,node);
//如果key存在,则刷新kye-value
}else {
node.value=value;
this.refreshNode(node);
}
}
public void remove(String key){
Node node=hashMap.get(key);
this.removeNode(node);
hashMap.remove(key);
}
/**
* 刷新被访问的节点
* @param node
*/
private void refreshNode(Node node){
//如果访问的尾节点,无需移动节点
if(node ==end){
return;
}
//移除节点
this.removeNode(node);
//重新插入节点
this.addNode(node);
}
/**
* 删除节点
* @param node
* @return
*/
private String removeNode(Node node){
if(node==end){
//移除尾节点
end=end.pre;
}else if(node==head.next){
//移除头节点
head=head.next;
}else {
node.pre.next=node.next;
node.next.pre=node.pre;
}
return node.key;
}
/**
* 尾部插入节点
* @param node
*/
private void addNode(Node node){
if(null!=end){
end.next=node;
node.pre=end;
node.next=null;
}
end=node;
if(null==head){
head=node;
}
}
class Node{
public Node pre;
public Node next;
public String key;
public String value;
Node(String key, String value){
this.key=key;
this.value=value;
}
}
}