Java 实现简单的内存对象LRU缓存

常遇到需要将对象在内存中缓存的场景.比如下面场景:

Android 即使通讯应用中,用户列表,对话页面,群聊页面等,都会有大量的用户信息展示需求,至少需要 名字,头像 等信息,需要从服务器获取.

而上述页面有高概率会再次访问,浏览的用户信息也有高概率再次曝光.

每次曝光都请求一次服务器显然太浪费,但将全部用户信息都缓存下来肯定也不合适,因此需要缓存用户信息.

于是自己做了一个简单的基于 LRU 规则的内存缓存容器.

LRU 即 Last Recent Used, 大意是最近被使用的对象最后被丢弃.

先上源码再扯其他:

源码:

package lx.af.utils.cache;

import android.support.annotation.NonNull;

import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;

/**
* author: lx
* date: 16-6-1
*
* simple memory object LRU cache. based on HashMap.
* usage of the cache is simple:
* specify a max object count and a purge threshold, then the cache is ready to go.
* or you can specify the max count, and the purge threshold will be set to max * 0.75.
*
* when to purge the cache:
* when add objects to the cache, total object count will be checked against max count.
* if exceeded, objects will be deleted due to access time order until count reaches threshold.
* access time of objects will be recorded on put() and get(), and items with shorter
* access time will get purged first.
* the purge operation will be done automatically.
*
* this class is threadsafe.
*
* @param <K> the type of keys maintained by cache. rule is the same as of HashMap.
* @param <V> the type of mapped values. rule is the same as of HashMap.
*/
public class SimpleMemLruCache<K, V> {

private HashMap<K, Wrapper<K, V>> mMap;
private int mMax;
private int mThreshold;

private final Object mLock = new Object();

/**
* create cache with max object count.
* the threshold will be set to max * 0.75.
* @param max max object count of the cache, exceed which will trigger object purge.
*/
public SimpleMemLruCache(int max) {
this(max, (int) (max * 0.75f));
}

/**
* create cache with both max object count and object purge threshold.
* threshold should not be greater then max, or else exception will be thrown.
* @param max max object count of the cache, exceed which will trigger object purge.
* @param threshold purge threshold: when object exceeds max count, object deletion
*                  will be triggered. oldest object will get deleted first,
*                  until object count reaches threshold.
*/
public SimpleMemLruCache(int max, int threshold) {
if (threshold > max) {
throw new IllegalArgumentException("threshold should not be greater than max");
}
mMax = max;
mThreshold = threshold;
mMap = new HashMap<>(max + 3);
}

/**
* put object to cache.
* when called, the object's last access time will be set to current time.
* @param key key, as in {@link HashMap#put(Object, Object)}
* @param value value, as in {@link HashMap#put(Object, Object)}
*/
public void put(K key, V value) {
synchronized (mLock) {
mMap.put(key, new Wrapper<>(key, value));
}
checkPrune();
}

/**
* get object from cache.
* when called, the object's last access time will be updated to current time.
* @param key key, as in {@link HashMap#get(Object)}
* @return value, as in {@link HashMap#get(Object)}
*/
public V get(K key) {
synchronized (mLock) {
Wrapper<K, V> wrapper = mMap.get(key);
if (wrapper != null) {
wrapper.update();
return wrapper.obj;
}
}
return null;
}

/**
* clear all cached objects.
*/
public void clear() {
synchronized (mLock) {
mMap.clear();
}
}

// check and purge objects
private void checkPrune() {
if (mMap.size() < mMax) {
return;
}
synchronized (mLock) {
// use list to sort the map first
LinkedList<Wrapper<K, V>> list = new LinkedList<>();
list.addAll(mMap.values());
Collections.sort(list);
// delete oldest objects
for (int i = list.size() - 1; i >= mThreshold; i --) {
Wrapper<K, V> wrapper = list.get(i);
mMap.remove(wrapper.key);
}
list.clear();
}
}

// wrapper class to record object's last access time.
private static class Wrapper<K, V> implements Comparable<Wrapper> {

K key;
V obj;
long updateTime;

Wrapper(K key, V obj) {
this.key = key;
this.obj = obj;
this.updateTime = System.currentTimeMillis();
}

void update() {
updateTime = System.currentTimeMillis();
}

@Override
public int compareTo(@NonNull Wrapper another) {
return (int) (updateTime - another.updateTime);
}
}

}

思路:

主要思路是,将 HashMap 作为内存容器, object 以键值对的形式存入这个 HashMap. 

当然存入 HashMap 时, value 被套了一层,以便记录最后访问时间.

缓存的构造接受两个参数: 最大对象数, 和清理对象时的对象数的阈值.

然后对象就可以不断存入. 每次有存入对象操作时,就会检查一次 HashMap 中的对象数是否超过了最大值.

如果超过最大值,则开始清理对象,直到对象数达到阈值.

这里用了两个参数来限定对象数目,是基于效率考虑:

如果只有一个对象最大数限制,那么在存入对象到达该最大数后,几乎每次存入都需要到缓存里找到那个最老的对象并删除之.

所以这里设置了一个阈值,比如最大对象数为100,阈值为75.那么在每次对象超过100时,就启动删除流程,删除到对象数为75.这样在接下来的25个对象存入动作中,都不会再触发删除操作,效率明显提高.

示例:

基于开篇提到的使用场景,大体使用方法如下:

// 创建缓存,最大对象数为100,阈值为75
SimpleMemLruCache<String, UserInfo> mUserCache = new SimpleMemLruCache<>(100, 75);

// 获取用户信息时,首先查看缓存内是否存在,不存在则请求服务器
String userId = "some_user_id";
UserInfo user = mUserCache.get(userId);
if (user == null) {
user = UserInfoRequest.get();
// 将请求到的用户信息放入缓存
mUserCache.put(userId, user);
}
displayUserInfo(user);

改进:

这个缓存实现是个超级简单的缓存实现,适用场景有限,有很多待改进的地方.

比如 LRU 算法一般不止会考虑更新时间那么简单,还会考虑被使用次数等.

比如这个cache只适用于对象数较少时,比如要存一万个对象的话,清理缓存的工作应该放在线程中去做.

清理操作放在线程中的话,同步也是问题.这样就要实现分步清理.

后期还需改进.