Glide内存缓存

Glide缓存分为两个方面内存缓存和磁盘缓存。

主要看一下内存缓存

GenericRequest调用onSizeReady函数，通过Engie.load加载图片.

load先从内存缓存中加载图片，有两个层级，一个是MemoryCache，一个是ActiveResouces。

        EngineResource<?> cached = loadFromCache(key, isMemoryCacheable);
        if (cached != null) {
            cb.onResourceReady(cached);
            if (Log.isLoggable(TAG, Log.VERBOSE)) {
                logWithTimeAndKey("Loaded resource from cache", startTime, key);
            }
            return null;
        }

        EngineResource<?> active = loadFromActiveResources(key, isMemoryCacheable);
        if (active != null) {
            cb.onResourceReady(active);
            if (Log.isLoggable(TAG, Log.VERBOSE)) {
                logWithTimeAndKey("Loaded resource from active resources", startTime, key);
            }
            return null;
        }

内存缓存根据key加载图片。
有两个部分：
1、图片存到内存的；
2、怎样取内存中的图片。


1、 图片存到内存的过程
图片加载完成后才会缓存，首先要看一下加载过程（无缓存、无active ）。

        EngineJob engineJob = engineJobFactory.build(key, isMemoryCacheable);
        DecodeJob<T, Z, R> decodeJob = new DecodeJob<T, Z, R>(key, width, height, fetcher, loadProvider, transformation,
                transcoder, diskCacheProvider, diskCacheStrategy, priority);
        EngineRunnable runnable = new EngineRunnable(engineJob, decodeJob, priority);
        jobs.put(key, engineJob);
        engineJob.addCallback(cb);
        engineJob.start(runnable);

这块有几个和加载相关的类：DecodeJob、EngineJob 、EngineRunnable 
DecodeJob：图片原始数据加载、解码
EngineRunnable ：一个中间类，DecodeJob和EngineJob的包装 ，调用DecodeJob加载图片数据，数据加载完成通知EngineJob。
EngineJob ：处理DecodeJob的加载结果。
 engineJob.start(runnable);提交EngineRunnable 给执行ExecutorService，EngineRunnable的Run方法执行decode():

        private Resource<?> decode() throws Exception {
            if (isDecodingFromCache()) {
                return decodeFromCache();
            } else {
                return decodeFromSource();
            }
        }  

加载图片数据，加载图片数据完成后（EngineRunnable，Run方法）调用：

if (resource == null) {
    onLoadFailed(exception);
} else {
    onLoadComplete(resource);
}

只看加载成功，调用onLoadComplete（EngineRunnable中）：

    private void onLoadComplete(Resource resource) {
        manager.onResourceReady(resource);
    }

onLoadComplete调用 manager.onResourceReady(resource);这个manager既是EngineJob

    public EngineRunnable(EngineRunnableManager manager, DecodeJob<?, ?, ?> decodeJob, Priority priority) {
        this.manager = manager;
        this.decodeJob = decodeJob;
        this.stage = Stage.CACHE;
        this.priority = priority;
    }

class EngineJob implements EngineRunnable.EngineRunnableManager，EngineJob 实现 EngineRunnable.EngineRunnableManager。

EngineJob 在onResourceReady中调用了

    public void onResourceReady(final Resource<?> resource) {
        this.resource = resource;
        MAIN_THREAD_HANDLER.obtainMessage(MSG_COMPLETE, this).sendToTarget();
    }

加载图片数据不在UI线程，所以图片回调到ImageView时得切到UI线程。
MAIN_THREAD_HANDLER初始化（EngineJob ）：

private static final Handler MAIN_THREAD_HANDLER = new Handler(Looper.getMainLooper(), new MainThreadCallback());

MAIN_THREAD_HANDLER 发送MSG_COMPLETE告知图片加载完成：

private static class MainThreadCallback implements Handler.Callback {
        @Override
        public boolean handleMessage(Message message) {
            if (MSG_COMPLETE == message.what || MSG_EXCEPTION == message.what) {
                EngineJob job = (EngineJob) message.obj;
                if (MSG_COMPLETE == message.what) {
                    job.handleResultOnMainThread();
                } else {
                    job.handleExceptionOnMainThread();
                }
                return true;
            }
            return false;
        }
    }

下面是缓存部分。

调用job.handleResultOnMainThread()三个主要功能：

a）回调Engine进行ActiveResouce资源缓存

b）回调给ImageView

c）进行MemoryCache

private void handleResultOnMainThread() {
        if (isCancelled) {
            resource.recycle();
            return;
        } else if (cbs.isEmpty()) {
            throw new IllegalStateException("Received a resource without any callbacks to notify");
        }
        engineResource = engineResourceFactory.build(resource, isCacheable);
        hasResource = true;
        engineResource.acquire();
        listener.onEngineJobComplete(key, engineResource);
        for (ResourceCallback cb : cbs) {
            if (!isInIgnoredCallbacks(cb)) {
                engineResource.acquire();
                cb.onResourceReady(engineResource);
            }
        }
        // Our request is complete, so we can release the resource.
        engineResource.release();
}

a）回调Engine进行ActiveResouce资源缓存，对应这行代码： listener.onEngineJobComplete(key, engineResource);

listener在Engine构造方法初始化，

 public void onEngineJobComplete(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.put(key, new ResourceWeakReference(key, resource, getReferenceQueue()));
            }
        }
        // TODO: should this check that the engine job is still current?
        jobs.remove(key);
}

b）回调给ImageView,对应 cb.onResourceReady(engineResource);

c）进行Memory缓存 ，对应engineResource.release();

在a、b时进行active缓存、回调给ImageView时，进行引用计数engineResource.acquire();

在最后对资源进行释放，在引用计数为0时，对资源进行Memory缓存；

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);
        }
}

listener，在onEngineJobComplete中赋值 resource.setResourceListener(key, this）回调到Engine中进行内存缓存。

public void onResourceReleased(Key cacheKey, EngineResource resource) {
    Util.assertMainThread();
    activeResources.remove(cacheKey);
    if (resource.isCacheable()) {
        cache.put(cacheKey, resource);
    } else {
        resourceRecycler.recycle(resource);
    }
}

2、 怎样取内存中的图片

        EngineResource<?> cached = loadFromCache(key, isMemoryCacheable);
        if (cached != null) {
            cb.onResourceReady(cached);
            if (Log.isLoggable(TAG, Log.VERBOSE)) {
                logWithTimeAndKey("Loaded resource from cache", startTime, key);
            }
            return null;
        }

        EngineResource<?> active = loadFromActiveResources(key, isMemoryCacheable);
        if (active != null) {
            cb.onResourceReady(active);
            if (Log.isLoggable(TAG, Log.VERBOSE)) {
                logWithTimeAndKey("Loaded resource from active resources", startTime, key);
            }
            return null;
        }