LRU最近最少使用算法

一、LRU算法

1.简介

LRU（Least Recently Used，最近最少使用）算法是一种常用的缓存淘汰策略，当缓存达到其容量上限时，它会移除那些最久没有被访问的数据项。这种策略基于这样一个假设：如果一个数据项在近期没有被访问过，那么在未来一段时间内也不太可能被访问。

2.LRU算法的核心思想

LRU算法的核心在于追踪每个数据项的访问历史，并优先保留最近被访问过的数据项。具体来说，每当有新的数据需要存储而缓存已满时，LRU算法会选择移除那个最长时间未被访问的数据项。

二、算法题目

1.LeetCode题目

146. LRU 缓存

2.实现

class LRUCache extends LinkedHashMap<Integer, Integer> {

        private int capacity;

        public LRUCache(int capacity) {
            super(capacity, 0.75F, true);
            this.capacity = capacity;
        }

        public int get(int key) {
            return getOrDefault(key, -1);
        }

        public void put(int key, int value) {
            super.put(key, value);
        }

        @Override
        protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
            return size() > capacity;
        }
    }

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

三、项目中实现

• 定义Cache接口

package com.zzc.design.cache;

import java.util.concurrent.Callable;

public interface Cache<K, V> {

    /**
     * 添加值到缓存中，如果key已经存在，值将会被覆盖
     * @param key
     * @param val
     */
    void put(K key, V val);

    /**
     * 根据key从缓存中获取value
     * @param key
     * @return
     */
    V get(K key);

    /**
     * “加载-通过”模式（load-through pattern）
     * 从缓存中获取值，如果该值不存在，则通过给定的函数处理并将其结果更新到缓存中。
     * @param key
     * @param call
     * @return
     * @throws Exception
     */
    V get(K key, Callable<? extends V> call) throws Exception;

    /**
     * 通过key移除缓存
     * @param key
     * @return
     */
    V remove(K key);

    /**
     * 清除整个缓存
     */
    void clear();

    /**
     * 缓存数量大小
     * @return
     */
    int getCapacity();

}

• 实现具体存储key-value数据的接口

package com.zzc.design.cache;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;

public class SimpleCache<K, V> implements Cache<K, V> {

    private final Map<K, V> cache;

    public SimpleCache(int size) {
        cache = new HashMap<>(size);
    }

    @Override
    public void put(K key, V val) {
        cache.put(key, val);
    }

    @Override
    public V get(K key) {
        return cache.get(key);
    }

    @Override
    public V get(K key, Callable<? extends V> call) throws Exception {
        if (cache.containsKey(key)) {
            return cache.get(key);
        } else {
            V v2 = call.call();
            cache.put(key, v2);
            return v2;
        }
    }

    @Override
    public V remove(K key) {
        return cache.remove(key);
    }

    @Override
    public void clear() {
        cache.clear();
    }

    @Override
    public int getCapacity() {
        return cache.size();
    }

}

• 拓展LRU缓存类型

package com.zzc.design.cache.lru;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.Callable;

public class LruCache<K, V> implements Cache<K, V> {

    /**
     * 存储键值对数据
     */
    private final Cache<K, V> delegate;

    /**
     * 跟踪键的访问顺序，从而实现 LRU 策略
     */
    private Map<K, V> visits;

    /**
     * 记录最近要被移除的最老键
     */
    private K eldestKey;

    public LruCache(Cache<K, V> delegate, int capacity) {
        this.delegate = delegate;
        setCapacity(capacity);
    }

    public void setCapacity(final int capacity) {
        visits = new LinkedHashMap<K, V>(capacity, .75F, true) {

            @Override
            protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
                boolean tooBig = size() > capacity;
                if (tooBig) {
                    eldestKey = eldest.getKey();
                }
                return tooBig;
            }
        };
    }

    @Override
    public void put(K key, V val) {
        delegate.put(key, val);
        cycleKeyList(key);
    }

    @Override
    public V get(K key) {
        visits.get(key);
        return delegate.get(key);
    }

    @Override
    public V get(K key, Callable<? extends V> call) throws Exception {
        return delegate.get(key, call);
    }

    @Override
    public V remove(K key) {
        return delegate.remove(key);
    }

    @Override
    public void clear() {
        delegate.clear();
        visits.clear();
    }

    @Override
    public int getCapacity() {
        return delegate.getCapacity();
    }

    private void cycleKeyList(K key) {
        visits.put(key, null);
        if (eldestKey != null) {
            delegate.remove(eldestKey);
            eldestKey = null;
        }
    }
}

• Demo示例

package com.zzc.design.cache.lru;

import com.zzc.design.cache.Cache;
import com.zzc.design.cache.SimpleCache;

public class Demo {

    private static final int initCapacity = 1;
    private static final int maxCapacity = 3;

    public static void main(String[] args) {
        Cache<String, String> cache = new LruCache<>(new SimpleCache<>(initCapacity), maxCapacity);
        cache.put("key1", "value1");
        cache.put("key2", "value2");
        cache.put("key3", "value3");
        System.out.println(cache.get("key1"));//访问key1
        System.out.println(cache.get("key2"));//访问key2
        System.out.println(cache.get("key3"));//访问key3
        System.out.println(cache.get("key1"));//访问key1
        System.out.println(cache.get("key2"));//访问key2
        cache.put("key4", "value4");//新增key4
        System.out.println(cache.get("key3"));//key3的访问次数最少，在添加key4的时候被删除掉了
    }

}
/*
 * 结果:
 * value1
 * value2
 * value3
 * value1
 * value2
 * null
 */