Redis缓存失效策略思考

no-enviction
禁止驱逐数据，新写入操作会报错


volatile-lru
从已设置过期时间的数据集选择最近最少使用的数据淘汰


volatile-ttl
从已设置过期时间的数据集选择将要过期的数据淘汰


volatile-random
从已设置过期时间的数据集选择任意的数据淘汰


allkeys-lru
从数据集选择最近最少使用的数据淘汰


allkeys-random
从数据集选择任意的数据淘汰
复制

/**
 * 元素对象
 *
 * @author 微信公众号「IT徐胖子」
 *
 */
public class CacheElement {
  private String key;
  private Object value;


  public CacheElement(String key, Object value) {
    this.key = key;
    this.value = value;
  }


  public String getKey() {
    return key;
  }


  public Object getValue() {
    return value;
  }


  @Override
  public String toString() {
    return "Element [key=" + key + ", value=" + value + "]";
  }
}


/**
 * LRU缓存策略
 *
 * @author 微信公众号「IT徐胖子」
 *
 */
public class LRUCache {
  private int capacity;
  private LinkedList<CacheElement> cache;


  public LRUCache(int capacity) {
    this.capacity = capacity;
    this.cache = new LinkedList<>();
  }


  /**
   * 获取缓存元素
   *
   * 找到元素后将元素从原位置删除并插入到链表头部（最近）
   */
  public CacheElement get(String key) {
    Iterator<CacheElement> iterator = cache.iterator();
    while (iterator.hasNext()) {
      CacheElement element = iterator.next();
      if (element.getKey().equals(key)) {
        iterator.remove();
        System.out.println("获取到元素=" + element);
        put(element.getKey(), element.getValue());
        return element;
      }
    }
    return null;
  }


  /**
   * 存储缓存元素
   *
   * 新元素插入到链表头部（最近）
   */
  public boolean put(String key, Object value) {
    Iterator<CacheElement> iterator = cache.iterator();
    while (iterator.hasNext()) {
      CacheElement element = iterator.next();
      if (element.getKey().equals(key)) {
        iterator.remove();
        break;
      }
    }
    if (capacity == cache.size()) {
      CacheElement deleteElement = cache.removeLast();
      System.out.println("容量已满删除尾部元素=" + deleteElement);
    }
    CacheElement element = new CacheElement(key, value);
    cache.addFirst(element);
    System.out.println("插入头部元素=" + element);
    return Boolean.TRUE;
  }


  @Override
  public String toString() {
    return "LRUCache [capacity=" + capacity + ", cache=" + cache + "]";
  }
}


/**
 * LRU测试实例
 *
 * @author 微信公众号「IT徐胖子」
 *
 */
public class TestCache {
  public static void main(String[] args) {
    System.out.println("==================存储缓存元素==================");
    LRUCache cache = new LRUCache(2);
    CacheElement element0 = new CacheElement("k0", "v0");
    CacheElement element1 = new CacheElement("k1", "v1");
    CacheElement element2 = new CacheElement("k2", "v2");
    cache.put(element0.getKey(), element0.getValue());
    cache.put(element1.getKey(), element1.getValue());
    cache.put(element2.getKey(), element2.getValue());


    System.out.println("==================获取缓存元素==================");
    System.out.println("获取元素之前缓存对象=" + cache);
    cache.get("k1");
    System.out.println("获取元素之后缓存对象=" + cache);
  }
}


==================存储缓存元素==================
插入头部元素=Element [key=k0, value=v0]
插入头部元素=Element [key=k1, value=v1]
容量已满删除尾部元素=Element [key=k0, value=v0]
插入头部元素=Element [key=k2, value=v2]


==================获取缓存元素==================
获取元素之前缓存对象=LRUCache [capacity=2, cache=[Element [key=k2, value=v2], Element [key=k1, value=v1]]]
获取到元素=Element [key=k1, value=v1]
插入头部元素=Element [key=k1, value=v1]
获取元素之后缓存对象=LRUCache [capacity=2, cache=[Element [key=k1, value=v1], Element [key=k2, value=v2]]]
复制