Glide都在用的LruCache，你会几分？
前言
说到Glide就有点尴尬，我原本想出一篇《手撕Glide》，可是很遗憾，源码实在太多了。写着写着就3000多字了，甚至还没写完，实在不合适，由于我写文的原则是短小精悍，因此就暂时不出这篇文章了，此次就先讲讲Glide都在用的LruCache有什么神奇之处。另外我抖音的面试在即，也不知道本身水平到了没有，如今出一篇算一篇先。java
思惟导图
使用方法及结果
在项目中直接导入Glide的库，调用内部的LruCache来看看效果。node
LruCache lruCache = new LruCache<String, Integer>(2);
lruCache.put("1", 1);
lruCache.put("2", 2);
lruCache.put("1", 1);
lruCache.put("3", 3);
System.out.println(lruCache.get("1"));
System.out.println(lruCache.get("2"));
System.out.println(lruCache.get("3"));
复制代码
简要说明代码内容，建立一个空间为2的存储空间（这里先不透漏内部结构），用put()方法对数据进行存储，再经过get()对每一个数据进行一次获取操做，而后咱们再来看看结果。面试
个人天！！2没了？ 这是怎么一回事？？为了知道答案，那咱们只好进入Glide的库中看看缘由了。算法
LruCache源码导读
先看看LruCache的变量家庭里有哪些小家伙把。数组
public class LruCache<T, Y> {
// 容量为100的双向链表
private final Map<T, Y> cache = new LinkedHashMap<>(100, 0.75f, true);
private final long initialMaxSize; // 初始化最大容量
private long maxSize; // 最大容量
private long currentSize; // 已存在容量
}
复制代码
一样对于LruCache来讲不也和HashMap同样只有三步骤要走嘛，那我就从这三个步骤入手探索一下LruCache好了，可是咱们要带上一个问题出发，initialMaxSize的做用是什么？缓存
new LruCache<T, Y>(size)
public LruCache(long size) {
this.initialMaxSize = size;
this.maxSize = size;
}
复制代码
到这里想来读者都已经知道套路了，也就初始化了初始化最大容量和最大容量，那就直接下一步。框架
put(key, value)
public synchronized Y put(@NonNull T key, @Nullable Y item) {
// 返回值就是一个1
final int itemSize = getSize(item);
// 若是1大于等于最大值就无操做
// 也就说明整个初始化的时候并不能将size设置成1
if (itemSize >= maxSize) {
//用于重写的保留方法
onItemEvicted(key, item);
return null;
}
// 对当前存在数据容量加一
if (item != null) {
currentSize += itemSize;
}
@Nullable final Y old = cache.put(key, item);
if (old != null) {
currentSize -= getSize(old);
if (!old.equals(item)) {
onItemEvicted(key, old);
}
}
evict(); // 1 -->
return old;
}
// 由注释1直接调用的方法
private void evict() {
trimToSize(maxSize); // 2 -->
}
// 由注释2直接调用的方法
protected synchronized void trimToSize(long size) {
Map.Entry<T, Y> last;
Iterator<Map.Entry<T, Y>> cacheIterator;
// 说明当前的容量大于了最大容量
// 须要对最后的数据进行一个清理
while (currentSize > size) {
cacheIterator = cache.entrySet().iterator();
last = cacheIterator.next();
final Y toRemove = last.getValue();
currentSize -= getSize(toRemove);
final T key = last.getKey();
cacheIterator.remove();
onItemEvicted(key, toRemove);
}
}
复制代码
这是一个带锁机制的方法，经过对当前容量和最大容量的判断，来抉择是否须要把咱们的数据进行一个删除。可是问题依旧存在，initialMaxSize的做用是什么？，咱们可以知道的是maxSize是一个用于控制容量大小的值。ide
get()
public synchronized Y get(@NonNull T key) {
return cache.get(key);
}
复制代码
那这就是调用了LinkedHashMap中的数据，可是终究仍是没有说出initialMaxSize的做用。函数
关于initialMaxSize
这里就不买关子了，由于其实就个人视角来看这个initialMaxSize确实是没啥用处的。哈哈哈哈哈！！！可是，又一个地方用到了它。post
public synchronized void setSizeMultiplier(float multiplier) {
if (multiplier < 0) {
throw new IllegalArgumentException("Multiplier must be >= 0");
}
maxSize = Math.round(initialMaxSize * multiplier);
evict();
}
复制代码
也就是用于调控咱们的最大容量大小，可是我以为仍是没啥用，但是是我太菜了吧，这个方法没有其余调用它的方法，是一个咱们直接在使用过程当中使用的，可能和数据屡次使用的一个保存之类的问题相关联把，场景的话也就相似Glide的图片缓存加载把。也但愿知道的读者能给我一个解答。
LinkedHashMap
由于操做方式和HashMap一致就再也不复述，就看看他的节点长相。
static class LinkedHashMapEntry<K,V> extends HashMap.Node<K,V> {
// 存在先后节点，也就是咱们所说的双向链表
LinkedHashMapEntry<K,V> before, after;
LinkedHashMapEntry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
复制代码
可是到这里，我又出现了一个问题，为何我没有看到整个数据的移动？也就是最近使用的数据应该调换到最后开始的位置，他到底实在哪里进行处理的呢？作一个猜测好了，既然是使用了put()才会形成双向链表中数据的变换，那咱们就应该是须要进入对LinkedHashMap.put()方法中进行查询。
固然有兴趣探索的读者们，我须要提一个醒，就是此次的调用不能够直接进行对
put()进行查询，那样只会调用到一个接口函数，或者是抽象类函数，最适合的方法仍是使用咱们的断点来进行探索查询。
可是通过一段努力后，不断深度调用探索发现这样的问题，他最后会调用到这样的问题。
// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) { } // 把数据移动到最后一位
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }
复制代码
这是以前咱们在了解HashMap是并无发现几个方法，上面也明确写着为LinkedHashMap保留。哇哦！！那咱们的操做确定实在这些里面了。
// --> HashMap源码第656行附近调用到下方方法
// 在putVal()方法内部存在这个出现
afterNodeAccess(e);
// --> LinkedHashMap对其具体实现
// 就是将当前数据直接推到最后一个位置
// 也就是成为了最近刚使用过的数据
void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMapEntry<K,V> last;
if (accessOrder && (last = tail) != e) {
LinkedHashMapEntry<K,V> p =
(LinkedHashMapEntry<K,V>)e, b = p.before, a = p.after;
p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a != null)
a.before = b;
else
last = b;
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
tail = p;
++modCount;
}
}
复制代码
好了，自此咱们也就清楚了整个链表的变换过程了。
实战：手撸LruCache
这是一个很是紧张刺激的环节了，撸代码前，咱们来找找思路好了。
（1）存储容器用什么？ 由于LinkedHashMap的思路太过冗长，咱们用数组来从新完成整个代码的构建
（2）关键调用方法put()、get()以及put()涉及的已存在变量移位。
哇哦！看来要作的事情也并无这么多,那咱们就先来看看第一次构造出来的框架好了。
public class LruCache {
private Object objects[];
private int maxSize;
private int currentSize;
public LruCache(int size){
objects = new Object[size];
maxSize = size;
}
/** * 插入item * @param item */
public void put(Object item){
}
/** * 获取item * @param item */
public Object get(Object item){
return null;
}
/** * 根据下标对应，将后续数组移位 * @param index */
public void move(int index){
}
}
复制代码
由于只要是数组变换就存在移位，因此移位操做是必不可少的。那咱们如今的工做也就是把数据填好了，对应的移位是怎么样的操做的思路了。
public class LruCache {
public Object objects[];
private int maxSize;
public int currentSize;
public LruCache(int size) {
objects = new Object[size];
maxSize = size;
}
/** * 插入item * * @param item */
public void put(Object item) {
// 容量未满时分红两种状况
// 1。 容器内存在
// 2。 容器内不存在
int index = search(item);
if (index == -1) {
if (currentSize < maxSize) { //容器未满，直接插入
objects[currentSize] = item;
currentSize++;
} else { // 容器已满，删去头部插入
move(0);
objects[currentSize - 1] = item;
}
}else {
move(index);
}
}
/** * 获取item * * @param item */
public Object get(Object item) {
int index = search(item);
return index == -1 ? null : objects[index];
}
/** * 根据下标对应，将后续数组移位 * * @param index */
public void move(int index) {
Object temp = objects[index];
// 将后续数组移位
for (int i = index; i < currentSize - 1; i++) {
objects[i] = objects[i + 1];
}
objects[currentSize - 1] = temp;
}
/** * 搜寻数组中的数组 * 存在则返回下标 * 不存在则返回 -1 * @param item * @return */
private int search(Object item) {
for (int i = 0; i < currentSize; i++) {
if (item.equals(objects[i])) return i;
}
return -1;
}
复制代码
由于已经真的写的比较详细了，也没什么难度的撸了个人20分钟，但愿读者们可以快入入门，下面给出个人一份测试样例，结束这个话题。
总结
想来咱们都知道在操做系统中有这样的问题须要思考，具体题型的话就是缺页中断。 用一个例题来完全了解LruCache的算法。
例： 存入内存的数据序列为：（1，2，1，3，2），内存容量为2。
| 最近使用 | 最久未使用 | 动做 |
|---|---|---|
| 1 | 1入内存 | |
| 2 | 1 | 2入内存 |
| 1 | 2 | 1入内存，交换1和2的使用频率 |
| 3 | 1 | 3入内存，内存不足，排出2 |
| 2 | 3 | 2入内存，内存不足，排出1 |
LruCache 主要用于缓存的处理,这里的缓存主要指的是内存缓存和磁盘缓存。
以上就是个人学习成果，若是有什么我没有思考到的地方或是文章内存在错误，欢迎与我分享。
相关文章推荐：
- 1. 都 Bootstrap 5 了，你还在用几？
- 2. 社会即将分层 你将会在第几层？
- 3. 分享几个职场人都在用的Excel小技巧，每个都能1分钟学会！
- 4. 几分钟几张图教你学会如何使用UML
- 5. LruCache的源码分析
- 6. 你想要的岁月都会给你.
- 7. excel中使用频率最多的几个操作技巧，办公达人都会，你会几个？
- 8. 学会这几个写作技巧，比你读书都管用，你别不信！
- 9. excel操作技巧都在这，连大神都需要必备的技巧，你不会的有几个
- 10. LruCache
- 更多相关文章...
- • Redis在Java Web中的应用 - Redis教程
- • 在Spring中使用Redis - Redis教程
- • TiDB 在摩拜单车在线数据业务的应用和实践
- • 再有人问你分布式事务，把这篇扔给他
-
每一个你不满意的现在，都有一个你没有努力的曾经。