Glide–LruCache源码分析(阅读量153,1赞)
LruCache原理和用法与LinkedHashMap(阅读量6472,7赞)
java容器类LinkedHashMap源码分析(阅读量23,1赞)
1、源码分析
======
LruCache算法,又称为近期最少使用算法。主要算法原理就是把最近所使用的对象的强引用存储在LinkedHashMap上,并且,把最近最少使用的对象在缓存池达到预设值之前从内存中移除。
先看源码:
public class LruCache<T, Y> {
private final LinkedHashMap<T, Y> cache = new LinkedHashMap<>(100, 0.75f, true);
private final int initialMaxSize;
private int maxSize;
private int currentSize = 0;
/**
-
Constructor for LruCache.
-
@param size The maximum size of the cache, the units must match the units used in {@link
-
#getSize(Object)}.
*/
public LruCache(int size) {
this.initialMaxSize = size;
this.maxSize = size;
}
/**
-
Sets a size multiplier that will be applied to the size provided in the constructor to put the
-
new size of the cache. If the new size is less than the current size, entries will be evicted
-
until the current size is less than or equal to the new size.
-
@param multiplier The multiplier to apply.
*/
public synchronized void setSizeMultiplier(float multiplier) {
if (multiplier < 0) {
throw new IllegalArgumentException(“Multiplier must be >= 0”);
}
maxSize = Math.round(initialMaxSize * multiplier);
evict();
}
/**
-
Returns the size of a given item, defaulting to one. The units must match those used in the
-
size passed in to the constructor. Subclasses can override this method to return sizes in
-
various units, usually bytes.
-
@param item The item to get the size of.
*/
protected int getSize(Y item) {
return 1;
}
/**
-
A callback called whenever an item is evicted from the cache. Subclasses can override.
-
@param key The key of the evicted item.
-
@param item The evicted item.
*/
protected void onItemEvicted(T key, Y item) {
// optional override
}
/**
- Returns the current maximum size of the cache in bytes.
*/
public synchronized int getMaxSize() {
return maxSize;
}
/**
- Returns the sum of the sizes of all items in the cache.
*/
public synchronized int getCurrentSize() {
return currentSize;
}
/**
-
Returns true if there is a value for the given key in the cache.
-
@param key The key to check.
*/
public synchronized boolean contains(T key) {
return cache.containsKey(key);
}
/**
-
Returns the item in the cache for the given key or null if no such item exists.
-
@param key The key to check.
*/
@Nullable
public synchronized Y get(T key) {
return cache.get(key);
}
/**
-
Adds the given item to the cache with the given key and returns any previous entry for the
-
given key that may have already been in the cache.
-
If the size of the item is larger than the total cache size, the item will not be added to
-
the cache and instead {@link #onItemEvicted(Object, Object)} will be called synchronously with
-
the given key and item.
-
@param key The key to add the item at.
-
@param item The item to add.
*/
public synchronized Y put(T key, Y item) {
final int itemSize = getSize(item);
if (itemSize >= maxSize) {
onItemEvicted(key, item);
return null;
}
final Y result = cache.put(key, item);
if (item != null) {
currentSize += getSize(item);
}
if (result != null) {
// TODO: should we call onItemEvicted here?
currentSize -= getSize(result);
}
evict();
return result;
}
/**
-
Removes the item at the given key and returns the removed item if present, and null otherwise.
-
@param key The key to remove the item at.
*/
@Nullable
public synchronized Y remove(T key) {
final Y value = cache.remove(key);
if (value != null) {
currentSize -= getSize(value);
}
return value;
}
/**
- Clears all items in the cache.
*/
public void clearMemory() {
trimToSize(0);
}
/**
-
Removes the least recently used items from the cache until the current size is less than the
-
given size.
-
@param size The size the cache should be less than.
*/
protected synchronized void trimToSize(int size) {
Map.Entry<T, Y> last;
while (currentSize > size) {
last = cache.entrySet().iterator().next();
final Y toRemove = last.getValue();
currentSize -= getSize(toRemove);
final T key = last.getKey();
cache.remove(key);
onItemEvicted(key, toRemove);
}
}
private void evict() {
trimToSize(maxSize);
}
}
什么是LRU算法? LRU是Least Recently Used的缩写,即最近最少使用,主要基于这样一个现实:在前面几条指令中使用频繁的数据很可能在后面的几条指令中频繁使用
LruCache采用的集合是LinkedHashMap,这个集合是HashMap的基础上增加了 数据链表的功能,可以看到下面这个构造函数,第一个是初始容量100, 第二个是碰撞因子0.75(即真实容量到达总容量的75%就开始扩容),第三个是链表顺序是否按访问顺序,关于这个容器的代码分析我们放在下一篇文章,在这里我们只需要知道这个集合能记录到你访问数据的次序,最近的访问的会放在链表的前面
private final LinkedHashMap<T, Y> cache = new LinkedHashMap<>(100, 0.75f, true);
initialMaxSize:初始大小,maxSize:最大,currentSize:当前 三个成员变量,创建时this.initialMaxSize 和this.maxSize 一样。 注意setSizeMultiplier函数的作用是传入一个变化乘数,改变当前的最大容量
private final int initialMaxSize;
private int maxSize;
private int currentSize = 0;
public LruCache(int size) {
this.initialMaxSize = size;
this.maxSize = size;
}
public synchronized void setSizeMultiplier(float multiplier) {
if (multiplier < 0) {
throw new IllegalArgumentException(“Multiplier must be >= 0”);
}
maxSize = Math.round(initialMaxSize * multiplier);
evict();
}
evict意思是驱逐,就是把数据清除出缓存,把容量缩减到小于等于maxSize,while循环,处理当前大小大于入参的情况,取出链表中的一个,获取其value的大小,清除,更新当前容器容量,直到符合要求
protected synchronized void trimToSize(int size) {
Map.Entry<T, Y> last;
while (currentSize > size) {
last = cache.entrySet().iterator().next();
final Y toRemove = last.getValue();
currentSize -= getSize(toRemove);
final T key = last.getKey();
cache.remove(key);
onItemEvicted(key, toRemove);
}
}
private void evict() {
trimToSize(maxSize);
}
获取item的大小,默认现在是1 。比如要实现一个Bitmap 缓存是需要返回大小的,缓存的大小是取决于所有bitmap的总大小和,而不是总个数
protected int getSize(Y item) {
return 1;
}
一个清除元素发生的回调,让LruCache 的继承者选择自己做要的事
protected void onItemEvicted(T key, Y item) {
// optional override
}
常规操作不解释
public synchronized int getMaxSize() {
return maxSize;
}
public synchronized int getCurrentSize() {
return currentSize;
}
public synchronized boolean contains(T key) {
return cache.containsKey(key);
}
@Nullable
public synchronized Y get(T key) {
return cache.get(key);
}
ut操作,首先获取待加入的item 大小,如果大于缓存最大容量,就不放进去,直接调用onItemEvicte. 小于缓存最大容量,执行放入,item不为空,更新缓存当前大小。 执行放入的结果result就是说如果之前在容器内key存在,会执行替换value的操作,这时候result!=null,需要把替换出来的item的大小减去, 作者弄了个//TODO,不知道这里是否加上onItemEvicted 的回调,个人感觉应该加上,毕竟数据被清除缓存了,通知下,怎么处理交给继承者。 最后 evict(),因为单个待处理的item大小小于缓存最大容量,但是加入后,有可能超出,这里加个维护容量的代码
public synchronized Y put(T key, Y item) {
final int itemSize = getSize(item);
if (itemSize >= maxSize) {
onItemEvicted(key, item);
return null;
}
final Y result = cache.put(key, item);
if (item != null) {
currentSize += getSize(item);
}
if (result != null) {
// TODO: should we call onItemEvicted here?
currentSize -= getSize(result);
}
evict();
return result;
}
清除key出缓存,常规操作,维护当前缓存大小
public synchronized Y remove(T key) {
final Y value = cache.remove(key);
if (value != null) {
currentSize -= getSize(value);
}
return value;
}
让缓存容量小于等于0,起到clearMemory的作用
public void clearMemory() {
trimToSize(0);
}
2、为什么用LinkedHashMap
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Android工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录大纲截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且后续会持续更新
如果你觉得这些内容对你有帮助,可以添加V获取:vip204888 (备注Android)
最后
下面是有几位Android行业大佬对应上方技术点整理的一些进阶资料。希望能够帮助到大家提升技术
高级UI,自定义View
UI这块知识是现今使用者最多的。当年火爆一时的Android入门培训,学会这小块知识就能随便找到不错的工作了。
不过很显然现在远远不够了,拒绝无休止的CV,亲自去项目实战,读源码,研究原理吧!
片转存中…(img-XVlMjrvD-1711937717186)]
[外链图片转存中…(img-eqoWj6FY-1711937717187)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Android开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录大纲截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且后续会持续更新
如果你觉得这些内容对你有帮助,可以添加V获取:vip204888 (备注Android)
[外链图片转存中…(img-XPnhcFnG-1711937717188)]
最后
下面是有几位Android行业大佬对应上方技术点整理的一些进阶资料。希望能够帮助到大家提升技术
[外链图片转存中…(img-LogJDKLN-1711937717189)]
高级UI,自定义View
UI这块知识是现今使用者最多的。当年火爆一时的Android入门培训,学会这小块知识就能随便找到不错的工作了。
不过很显然现在远远不够了,拒绝无休止的CV,亲自去项目实战,读源码,研究原理吧!
[外链图片转存中…(img-TSePcToi-1711937717189)]