无处不在,搜你所想

————— 两个月前 —————

用户信息当然存储在数据库中。但是，由于用户系统的高性能要求，数据库显然不能查询每个请求。

因此，小灰在内存中创建一个hash表作为缓存，每次查找用户时，首先在hash表中查询它，以提高访问性能。

很快，用户系统上线了，小灰美美地休息了几天。

一个多月之后......

———————————————

什么是哈希链表呢？

我们都知道哈希表由几个键值组成。在“逻辑”中，无论谁是相同的，这些键值都是无法区分的顺序。

在散列列表中，这些键值不再相互独立，而是链接在一起。每个键值都有其前身键值和后续键值，就像双链表中的节点一样。

这样一来，原本无序的哈希表拥有了固定的排列顺序。

让我们以用户信息为例来说明LRU算法的基本思想:

1. 假设我们使用一个哈希列表来缓存用户信息。目前，缓存了4个用户。这4个用户按时间顺序从列表的右端按顺序插入。

2. 此时，业务方访问用户5。由于散列列表中没有用户5数据，所以我们从数据库中读取数据并将其插入缓存。此时，列表的最右端是最近访问的用户5，而最左端是最近访问的用户1。

3.接下来，业务方访问用户2，哈希列表中有用户2数据。我们怎么做呢?我们将用户2从其前辈节点和后继节点中移除，并将其重新插入列表的最右侧。此时，链表的最右端成为最近访问的用户2，而最左端仍然是最近访问的用户1。

4. 接下来，业务方请求修改用户4的信息。同样，我们将用户4从其原始位置移动到链表的最右侧，并更新用户信息的值。此时，列表的最右端是最近访问的用户4，而最左端仍然是最近访问的用户1。

5. 后来，业务端改变了口味，访问用户6，用户6不在缓存中，需要插入哈希列表。假设此时缓存容量已达到上限，必须先删除最近访问的最少数据，然后删除哈希列表最左边的用户1，然后将用户6插入最右边。

以上，就是LRU算法的基本思路。

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 (node == null){

return null;

}

refreshNode(node);

return node.value;

}

public void put(String key, String value) {

Node node = hashMap.get(key);

if (node == null) {

//如果key不存在，插入key-value

if (hashMap.size() >= limit) {

String oldKey = removeNode(head);

hashMap.remove(oldKey);

}

node = new Node(key, value);

addNode(node);

hashMap.put(key, node);

}else {

//如果key存在，刷新key-value

node.value = value;

refreshNode(node);

}

}

public void remove(String key) {

Node node = hashMap.get(key);

removeNode(node);

hashMap.remove(key);

}

/**

* 刷新被访问的节点位置

* @param node 被访问的节点

*/

private void refreshNode(Node node) {

//如果访问的是尾节点，无需移动节点

if (node == end) {

return;

}

//移除节点

removeNode(node);

//重新插入节点

addNode(node);

}

/**

* 删除节点

* @param node 要删除的节点

*/

private String removeNode(Node node) {

if (node == end) {

//移除尾节点

end = end.pre;

}else if(node == head){

//移除头节点

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(end != null) {

end.next = node;

node.pre = end;

node.next = null;

}

end = node;

if(head == null){

head = node;

}

}

class Node {

Node(String key, String value){

this.key = key;

this.value = value;

}

public Node pre;

public Node next;

public String key;

public String value;

}

public static void main(String[] args) {

LRUCache lruCache = new LRUCache(5);

lruCache.put("001", "用户1信息");

lruCache.put("002", "用户1信息");

lruCache.put("003", "用户1信息");

lruCache.put("004", "用户1信息");

lruCache.put("005", "用户1信息");

lruCache.get("002");

lruCache.put("004", "用户2信息更新");

lruCache.put("006", "用户6信息");

System.out.println(lruCache.get("001"));

System.out.println(lruCache.get("006"));

}

需要注意的是，这段不是线程安全的，要想做到线程安全，需要加上synchronized修饰符。