1.背景

LRU(Least Recently Used)是一种常用的缓存淘汰策略，即当缓存满了之后，删除最近最少使用的数据。

LRU的实现，常用的编程语言在语言层面都有实现，可以直接使用。为了深入理解LRU，本文介绍一种通过双链表实现LRU方法。

2.双链表实现方法

Java版双链表实现代码。

2.1 定义节点实体类

/** * 链表节点. * @author liunan1 . */public class Node {  private int key;

  private int value;

  private Node next;

  private Node prev;

  public Node(int key, int value) {    this.key = key;    this.value = value;  }

  public int getKey() {    return key;  }

  public int getValue() {    return value;  }

  public Node getNext() {    return next;  }

  public void setNext(Node next) {    this.next = next;  }

  public Node getPrev() {    return prev;  }

  public void setPrev(Node prev) {    this.prev = prev;  }}

2.2 双链实现类

package lewis.test.algorithm.lru.model;

import java.util.Objects;

/** * 双链表. * @author liunan1 . */public class IntList {  private int length;  private Node head;  private Node tail;

  /**   *  删除最后一个节点.   */  public void removeLast() {    if (Objects.nonNull(tail) && Objects.nonNull(tail.getPrev())) {      Node prev = tail.getPrev();      prev.setNext(null);      tail = prev;      --length;    }  }

  /**   * 查找数据，未找到返回-1.   * @param key   * @return   */  public int get(int key) {    int i = 1;    Node currentNode = head;    for(; i <= length; i++) {      int findKey = currentNode.getKey();      int value = currentNode.getValue();      Node prev = currentNode.getPrev();      Node next = currentNode.getNext();      if (findKey == key) {        // 将节点移动到链表头部        if (Objects.nonNull(prev)) {           // 1.将节点移除           prev.setNext(next);           if (Objects.nonNull(next)) {             next.setPrev(prev);           } else {             // 节点队尾，更新队尾指针.             tail = prev;           }           // 2. 将节点移动到表头           currentNode.setNext(head);           head.setPrev(currentNode);           currentNode.setPrev(null);           head = currentNode;        }        return value;      }      currentNode = next;    }    // 未找到    return -1;  }

  /**   * 头部插入节点.   * @param node node.   */  public void addHead(Node node) {    head.setPrev(node);    node.setNext(head);    head = node;    ++length;  }

  /**   * 链表长度.   * @return 长度.   */  public int size() {     return length;  }}

2.3 LRU模拟实现类

package lewis.test.algorithm.lru.model;

import java.util.Random;

/** * LRU缓存淘汰策略实现类. * @author liunan1 . */public class LeastRecentlyUsedCache {  // 缓存容量  private int capacity;  private IntList list;

  public LeastRecentlyUsedCache(int capacity) {    this.capacity = capacity;  }

  /**   * 从缓存中获取数据.   * @param key .   * @return   */  public int get(int key) {    int value = this.list.get(key);    // 未找到，从磁盘读取.    if (-1 == value) {      // 模拟从磁盘读取.      value = new Random().nextInt(100);      // 插入缓存.      put(key, value);    }    return value;  }

  /**   * 插入数据.   * @param key key.   * @param value value.   */  public void put(int key, int value) {      Node node = new Node(key, value);      list.addHead(node);

      if (list.size() > capacity) {         list.removeLast();      }  }

}

3. 总结与思考

通过三个Java类，模拟实现了LRU，简单明了，易于理解。用心的读取也许已经发现，该实现查找缓存的时候，性能不够好，时间复杂度是O(n)。后续将对该实现进行优化，将时间复杂度提升到O(1)。