5分钟手撸一个简单、易用的缓存组件，架构师都对我刮目相看

我们还用Map类型存储，新增一个Map类型属性

// 存储缓存对象

private Map<K, V> cacheMap;

3. 选择合适淘汰策略

这里我选用实现简单的LFU(least frequently used) 最少使用率策略，来说明一下大致原理，其他实现类似的。

LFU：根据使用次数来判定对象是否被持续缓存（使用率是通过访问次数计算），当缓存满时清理过期对象，清理后依旧满的情况下清除最少访问（访问计数最小）的对象并将其他对象的访问数减去这个最小访问数，以便新对象进入后可以公平计数。

这里要做到LFU，需要以下属性：

• value 缓存对象

• latestTime 最新访问时间 ，用于判断对象是否过期，惰性删除的时候使用。

• count 访问次数 ，用于LFU判断。

• ttl 对象存活时长，用于判断对象是否过期，惰性删除的时候使用。

代码如下：

public class CacheObject {

/**

• 缓存对象

*/

V value;

/**

• 最新访问时间

*/

long latestTime;

/**

• 访问次数

*/

int count;

/**

• 对象存活时长，0表示永久存活

*/

private final long ttl;

/**

• 构造

• @param value 值

• @param ttl 超时时长

*/

protected CacheObject(V value, long ttl) {

this.value = value;

this.ttl = ttl;

this.latestTime = System.currentTimeMillis();

}

整体实现代码框架

我们整理下上面的思路，转化为代码龙骨。

/**

• LFU 最少使用率策略

• @param

• @param

*/

public class LFUCache<K, V> implements ICache<K, V> {

// 容量大小

private int capacity;

// 存储缓存对象

private Map<K, CacheObject> cacheMap;

public LFUCache(int capacity) {

this.capacity = capacity;

this.cacheMap = new HashMap<>(capacity, 1.0f);

}

@Override

public void put(K key, V value, long timeout) {

}

@Override

public V get(K key) {

return null;

}

@Override

public void remove(K key) {

}

}

有了这个龙骨，那么下面我们就根据它来把空白的地方填满吧，继续实现丰满我们的组件吧！

丰满相关实现

---

1. 将对象加入到缓存put操作

相关流程如下：

伪代码如下：

public void put(K key, V value, long timeout) {

if (缓存满了) {

删除所有的存活到期的对象();

if(缓存满了) {

删除一个访问次数最少的对象();

}

}

cacheMap.put(key, new CacheObject<>(value, timeout));

}

关键点

• 存活到期对象的判断

CacheObject.latestTime + CacheObject.ttl < System.currentTimeMillis()

• 删除访问次数最少的对象时，将其他对象的访问数减去这个最小访问数，否则老的数据越来越大，对新进入对象不公平，随着时间的增长，还有可能溢出。

2. 从缓存中获得对象get操作

相关流程如下：

大致代码如下：

public V get(K key) {

CacheObject cacheObject = cacheMap.get(key);

if (cacheObject == null) {

return null;

}

cacheObject.latestTime = System.currentTimeMillis();

cacheObject.count++;

return cacheObject.value;

}

关键点

• 每次访问到的对象，要更新最新访问时间和访问次数

3. 从缓存中删除对象remove操作

这里简单的调用Map的删除接口即可

public void remove(K key) {

cacheMap.remove(key);

}

好了，写到这儿，我们的缓存组件就基本成型了。

为什么说基本成型？

如果你真的是用心在看的话，估计会提问了卧槽，你这个压根线程非安全啊？

是的，那么我们来给每个方法加个synchronized即可，jdk1.6之后synchronized性能很强劲的。

整体代码如下

---

public class LFUCache<K, V> implements ICache<K, V> {

// 容量大小

private int capacity;

// 存储缓存对象

private Map<K, CacheObject> cacheMap;

public LFUCache(int capacity) {

this.capacity = capacity;

this.cacheMap = new HashMap<>(capacity, 1.0f);

}

@Override

public synchronized void put(K key, V value, long timeout) {

if (isFull()) {

pruneCache();

}

cacheMap.put(key, new CacheObject<>(value, timeout));

}

@Override

public synchronized V get(K key) {

CacheObject cacheObject = cacheMap.get(key);

if (cacheObject == null) {

return null;

}

cacheObject.latestTime = System.currentTimeMillis();

cacheObject.count++;

return cacheObject.value;

}

@Override

public synchronized void remove(K key) {

cacheMap.remove(key);

}

public boolean isFull() {

return (capacity > 0) && (cacheMap.size() >= capacity);

}

protected int pruneCache() {

int count = 0;

CacheObject comin = null;

// 清理过期对象并找出访问最少的对象

Iterator<CacheObject> values = cacheMap.values().iterator();

CacheObject co;

while (values.hasNext()) {

co = values.next();

if (co.isExpired() == true) {

values.remove();

count++;

continue;

}

//找出访问最少的对象

if (comin == null || co.count < comin.count) {

comin = co;

}

}

// 减少所有对象访问量，并清除减少后为0的访问对象

if (isFull() && comin != null) {

long minAccessCount = comin.count;

values = cacheMap.values().iterator();

CacheObject co1;

while (values.hasNext()) {

co1 = values.next();

co1.count -= minAccessCount;

if (co1.count <= 0) {

values.remove();

count++;

}

}

}

return count;

}

}

验证

---

测试代码如下：

//通过实例化对象创建

LFUCache<String, String> lfuCache = new LFUCache<String, String>(3);

lfuCache.put(“key1”, “value1”, DateUnit.SECOND.getMillis() * 3);

lfuCache.get(“key1”);//使用次数+1

lfuCache.put(“key2”, “value2”, DateUnit.SECOND.getMillis() * 3);

lfuCache.put(“key3”, “value3”, DateUnit.SECOND.getMillis() * 3);

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
等大厂，18年进入阿里一直到现在。**

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-6919jyox-1715664039263)]

[外链图片转存中…(img-TecZLbI7-1715664039264)]

[外链图片转存中…(img-EBlp5pkw-1715664039264)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！