阅读本文需要先了解Glide加载流程
缓存的分类
首先介绍一下Glide中对图片资源的封装类：EngineResource
class EngineResource<Z> implements Resource<Z> {
private final boolean isCacheable;
private final boolean isRecyclable;
private ResourceListener listener; // 分析1
private Key key;
private int acquired; // 分析2
private boolean isRecycled;
private final Resource<Z> resource;
}
- 回调，当这个资源不使用时，触发这个回调由上层处理，一般用于回收工作
- 用一个int记录这个资源被使用的次数，使用+1，释放-1，当int = 0 时，回调上一个接口；
void acquire() {
if (isRecycled) {
throw new IllegalStateException("Cannot acquire a recycled resource");
}
if (!Looper.getMainLooper().equals(Looper.myLooper())) {
throw new IllegalThreadStateException("Must call acquire on the main thread");
}
++acquired;
}
void release() {
if (acquired <= 0) {
throw new IllegalStateException("Cannot release a recycled or not yet acquired resource");
}
if (!Looper.getMainLooper().equals(Looper.myLooper())) {
throw new IllegalThreadStateException("Must call release on the main thread");
}
if (--acquired == 0) {
listener.onResourceReleased(key, this);
}
}
活动缓存：ActiveResources
final class ActiveResources {
@VisibleForTesting
final Map<Key, ResourceWeakReference> activeEngineResources = new HashMap<>(); // 缓存
private ResourceListener listener;
@Nullable
private ReferenceQueue<EngineResource<?>> resourceReferenceQueue; // 用于监听回收
@Nullable
private Thread cleanReferenceQueueThread;
private volatile boolean isShutdown;
@Nullable
private volatile DequeuedResourceCallback cb;
}
在活动缓存中，使用了一个map用来存放EngineResource对象，这里需要注意一个操作，就是这个EngineResource对象是用WeakReference包裹的，并且通过ReferenceQueue监听了EngineResource的回收，在回收的时候会清理当前的活动缓存内容；
下面分析一下源码是如果实现的：
首先，自定义一个WeakReference类，将key和resource传进入（用于在WeakReference回收的时候释放），传入一个ReferenceQueue对象，用于监听WeakReference回收
ResourceWeakReference toPut =
new ResourceWeakReference(
key,
resource,
getReferenceQueue(),
isActiveResourceRetentionAllowed);
开启一个子线程，在循环中监听ReferenceQueue的返回值，通过这个返回值，判断WeakReference有没有回收，监听的方法是ReferenceQueue.remove(),这是一个阻塞方法；所以要开子线程；
private ReferenceQueue<EngineResource<?>> getReferenceQueue() {
if (resourceReferenceQueue == null) {
resourceReferenceQueue = new ReferenceQueue<>();
cleanReferenceQueueThread = new Thread(new Runnable() {
@Override
public void run() {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
cleanReferenceQueue();
}
}, "glide-active-resources");
cleanReferenceQueueThread.start();
}
return resourceReferenceQueue;
}
@Synthetic void cleanReferenceQueue() {
while (!isShutdown) {
try {
ResourceWeakReference ref = (ResourceWeakReference) resourceReferenceQueue.remove(); // 监听是否回收
mainHandler.obtainMessage(MSG_CLEAN_REF, ref).sendToTarget();
// This section for testing only.
DequeuedResourceCallback current = cb;
if (current != null) {
current.onResourceDequeued();
}
// End for testing only.
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
内存缓存 LruResourceCache
LruResourceCache继承了LruCache类，关于LruCache类，简单提一下，具体的可以参考我之前的博客LruCache实现，LruCache继承了LinkedHashMap，LinkedHashMap有一个特点，就get后的数据会移动到队列，这就是Lru思想：固定一个容量，put的时候如果超过容量了，将最后一个节点删除，get的时候将get的这个节点移动到队列的头部；
public class LruResourceCache extends LruCache<Key, Resource<?>> implements MemoryCache {
private ResourceRemovedListener listener; // 监听被Lru算法淘汰的节点
@Override
protected void onItemEvicted(@NonNull Key key, @Nullable Resource<?> item) {
if (listener != null && item != null) {
listener.onResourceRemoved(item);
}
}
/** // 监听被Lru算法淘汰的节点
* An interface that will be called whenever a bitmap is removed from the cache.
*/
interface ResourceRemovedListener {
void onResourceRemoved(@NonNull Resource<?> removed);
}
onItemEvicted（）方法是LruCache的一个空方法，调用的时机是在put的时候判断是否超过容量，如果超过容量了，就淘汰最后一个节点，并调用这个方法；
活动缓存和内存缓存都是缓存在内存中的，活动缓存缓存的是正在使用的图片资源，当图片不使用时会放到内存缓存中，提出活动缓存的目的：单一的内存缓存由于Lru的淘汰机制会导致图片加载不稳定
磁盘缓存：
首先介绍一个磁盘缓存方案DiskLruCache(非Google官方编写，但获得官方认证)，关于这个磁盘缓存方案的理解可以看郭林的这片文章：
Android DiskLruCache完全解析，硬盘缓存的最佳方案
缓存的实现
从上一篇文章知道，Glide加载操作是通过Engine来驱动的
Engine:
public <R> LoadStatus load() {
...
// 根据当前图片加载请求生成key
EngineKey key = keyFactory.buildKey(model, signature, width, height, transformations,
resourceClass, transcodeClass, options);
// 分析1 ，活动缓存取
EngineResource<?> active = loadFromActiveResources(key, isMemoryCacheable);
// 分析2 ， 内存缓存取
EngineResource<?> cached = loadFromCache(key, isMemoryCacheable);
...
}
-
分析1：尝试读取活动缓存
private final ActiveResources activeResources; // 活动缓存
@Nullable
private EngineResource<?> loadFromActiveResources(Key key, boolean isMemoryCacheable) {
if (!isMemoryCacheable) {
return null;
}
EngineResource<?> active = activeResources.get(key);
if (active != null) {
active.acquire(); // 计数+1
}
return active;
}
-
分析2：
private final MemoryCache cache; // 内存缓存
private EngineResource<?> loadFromCache(Key key, boolean isMemoryCacheable) {
if (!isMemoryCacheable) {
return null;
}
// 获取内存缓存
EngineResource<?> cached = getEngineResourceFromCache(key);
if (cached != null) {
// 放入活动缓存
cached.acquire();
activeResources.activate(key, cached);
}
return cached;
}
private EngineResource<?> getEngineResourceFromCache(Key key) {
// 内存缓存中取
Resource<?> cached = cache.remove(key);
return result;
}
Engine的load()中，首先尝试从活动缓存和内存缓存获取缓存，如果没有缓存再启动EngineJob和DecodeJob；上面介绍了缓存的获取，下面看一下缓存的存放，肯定是在获取到图片后的回调中存放的
Engine.onEngineJobComplete()
@Override
public void onEngineJobComplete(EngineJob<?> engineJob, Key key, EngineResource<?> resource) {
Util.assertMainThread();
// A null resource indicates that the load failed, usually due to an exception.
if (resource != null) {
resource.setResourceListener(key, this);
if (resource.isCacheable()) {
activeResources.activate(key, resource);
}
}
jobs.removeIfCurrent(key, engineJob);
}
在DecodeJob获取到图片数据后，会回调很多接口，在回调中会将其放入活动缓存，当图片不在使用的时候，就会放入内存缓存，根据上面介绍的活动缓存规则，当EngineResource计数为0时就应该放入内存缓存；
Engine：当EngineResource计数为0时会调用
@Override
public void onResourceReleased(Key cacheKey, EngineResource<?> resource) {
Util.assertMainThread();
activeResources.deactivate(cacheKey);
if (resource.isCacheable()) {
cache.put(cacheKey, resource);
} else {
resourceRecycler.recycle(resource);
}
}
当资源引用为0，回调onResourceReleased(),从活动缓存移除，放入内存缓存；
磁盘缓存的实现：
上面介绍了活动缓存和内存缓存的存放和获取，下面看一看磁盘缓存的存取；
还记得DataFetcherGenerator接口吗？这个接口是DecodeJob用于获取数据的，有三个具体的实现：
- ResourceCacheGenerator: 资源文件
- DataCacheGenerator: 缓存文件
- SourceGenerator: 网络文件
我们在上一篇具体介绍的是网络文件的获取，这里的磁盘缓存使用的就是DataCacheGenerator（缓存文件）这个Generator了
DataCacheGenerator
@Override
public boolean startNext() {
Key sourceId = cacheKeys.get(sourceIdIndex);
Key originalKey = new DataCacheKey(sourceId, helper.getSignature());
// 分析1
cacheFile = helper.getDiskCache().get(originalKey);
while (!started && hasNextModelLoader()) {
ModelLoader<File, ?> modelLoader = modelLoaders.get(modelLoaderIndex++);
loadData =
modelLoader.buildLoadData(cacheFile, helper.getWidth(), helper.getHeight(),
helper.getOptions());
if (loadData != null && helper.hasLoadPath(loadData.fetcher.getDataClass())) {
started = true;
loadData.fetcher.loadData(helper.getPriority(), this);
}
}
return started;
}
- 从disk获取缓存
磁盘缓存的存放：
上篇文章知道DecodeJob是一个Runnable任务，在run()会调用runWrapped()，在runWrapped()中会做三种事情：
- getNextGenerator()，获取不同的Generator
- runGenerators()：执行generator获取数据
- decodeFromRetrievedData():解码
private void decodeFromRetrievedData() {
...
if (resource != null) {
notifyEncodeAndRelease(resource, currentDataSource);
} else {
runGenerators();
}
}
private void notifyEncodeAndRelease(Resource<R> resource, DataSource dataSource) {
...
try {
if (deferredEncodeManager.hasResourceToEncode()) {
deferredEncodeManager.encode(diskCacheProvider, options);
}
}
...
}
void encode(DiskCacheProvider diskCacheProvider, Options options) {
GlideTrace.beginSection("DecodeJob.encode");
try {
diskCacheProvider.getDiskCache().put(key,
new DataCacheWriter<>(encoder, toEncode, options));
} finally {
toEncode.unlock();
GlideTrace.endSection();
}
}
在runWrapped（）的解码操作中会执行decode()，在decode()中，会disk put操作;
Glide的磁盘缓存是基于DiskLruCache实现的，Glide直接使用的是DiskLruCacheWrapper对象对DiskLruCache 的封装；
