设计并实现一个并发安全的LRU(Least Recently Used,最近最少使用)缓存结构

文章目录

前言

相信很多人都使用过LinkedHashMap,LinkedHashMap中的removeEldestEntry可以删除老旧的元素,我们可以以此来实现一个LRU缓存结构,并结合java中JUC包中的各种多线程锁机制来保证多线程安全。

以下是我遇见过的一个高级面试题:

【面试题】设计并实现一个并发安全的LRU(Least Recently Used,最近最少使用)缓存结构。要求支持以下操作:

get(key):如果键存在于缓存中,则获取其对应的值(总是返回最新添加的值),否则返回-1。

put(key, value):如果键已经存在,则更新其对应的值;如果键不存在,并且缓存未满,则添加该键值对到缓存中;如果缓存已满,则移除最近最少使用的键值对,然后再将新的键值对添加到缓存。

实战演示

可以采用LinkedHashMap的removeEldestEntry方法删除需要淘汰的元素,并直接使用map的get/put方法。

模拟代码

bash 复制代码
import java.util.LinkedHashMap;
import java.util.Map;


/**
 * LRUCache
 * @author senfel
 * @date 2024/2/26 12:50
 */
public class LRUCache<K, V> {
    private final int capacity;
    private LinkedHashMap<K, V> cache;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        // 设置访问顺序和插入顺序一致,且当容量达到阈值时自动删除最近最少使用的项
        this.cache = new LinkedHashMap<K, V>(capacity, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
                return size() > capacity;
            }
        };
    }

    /**
     * get
     * @author senfel
     * @date 2024/2/26 12:52
     * @return V 
     */
    public V get(K key) {
        synchronized (cache) {
            return cache.getOrDefault(key, null);
        }
    }
    /**
     * put
     * @author senfel
     * @date 2024/2/26 12:52
     * @return void
     */
    public void put(K key, V value) {
        synchronized (cache) {
            cache.put(key, value);
        }
    }
}

上述代码实现了一个基本的LRU缓存结构,但get方法在key不存在时返回null而不是-1,并且没有完全解决并发访问问题。而且我们在获取到已经存在的是数据后并没有刷新数据,也就是并没有实现醉经最少使用的淘汰策略。
下面是更完善的版本,包含正确的get方法逻辑以及线程安全的put和get操作,以及在获取到数据后将数据重新刷新了。

优化后的代码

bash 复制代码
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.LinkedHashMap;
import java.util.Map;
/**
 * LRUCache
 * @author senfel
 * @date 2024/2/26 12:55
 */
public class LRUCache<K, V> {
    private final int capacity;
    private final LinkedHashMap<K, V> cache;
    private final Lock lock = new ReentrantLock();

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.cache = new LinkedHashMap<K, V>(capacity + 1, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
                return size() > capacity;
            }
        };
    }
    /**
     * get
     * @author senfel
     * @date 2024/2/26 12:58
     * @return V 
     */
    public V get(K key) {
        lock.lock();
        try {
            V value = cache.get(key);
            if (value != null) {
                // 触发访问,使得此条目变为最近使用过的
                cache.remove(key);
                cache.put(key, value);
            }
            return value;
        } finally {
            lock.unlock();
        }
    }
    /**
     * get
     * @author senfel
     * @date 2024/2/26 12:58
     * @return void
     */
    public void put(K key, V value) {
        lock.lock();
        try {
            // 首先尝试移除旧的键值对,即使它可能不存在
            cache.remove(key);
            cache.put(key, value);
        } finally {
            lock.unlock();
        }
    }
}

写在最后

在这个高级版本的LRU缓存实现中,我们使用了LinkedHashMap作为基础数据结构,并通过重写removeEldestEntry方法实现了缓存满时自动淘汰最久未使用的元素。同时,为了保证在多线程环境下的线程安全性,我们在get和put方法上加了synchronized关键字或者使用了ReentrantLock来确保同一时间只有一个线程能执行修改缓存的操作。在get方法中,我们还额外做了一步,即在获取到key对应值后重新插入以更新其为最近使用的元素。

相关推荐
奶糖趣多多44 分钟前
Redis知识点
数据库·redis·缓存
阿伟*rui44 分钟前
配置管理,雪崩问题分析,sentinel的使用
java·spring boot·sentinel
CoderIsArt2 小时前
Redis的三种模式:主从模式,哨兵与集群模式
数据库·redis·缓存
XiaoLeisj3 小时前
【JavaEE初阶 — 多线程】单例模式 & 指令重排序问题
java·开发语言·java-ee
paopaokaka_luck3 小时前
【360】基于springboot的志愿服务管理系统
java·spring boot·后端·spring·毕业设计
dayouziei3 小时前
java的类加载机制的学习
java·学习
Yaml45 小时前
Spring Boot 与 Vue 共筑二手书籍交易卓越平台
java·spring boot·后端·mysql·spring·vue·二手书籍
小小小妮子~5 小时前
Spring Boot详解:从入门到精通
java·spring boot·后端
hong1616885 小时前
Spring Boot中实现多数据源连接和切换的方案
java·spring boot·后端
aloha_7895 小时前
从零记录搭建一个干净的mybatis环境
java·笔记·spring·spring cloud·maven·mybatis·springboot