Glide 图片加载框架

public <T, Z, R> LoadStatus load(Key signature, int width, int height,
    DataFetcher<T> fetcher, DataLoadProvider<T, Z> loadProvider,
    Transformation<Z> transformation, ResourceTranscoder<Z, R> transcoder,
    Priority priority, boolean isMemoryCacheable,
    DiskCacheStrategy diskCacheStrategy, ResourceCallback cb) {
    // 1、工厂模式生成缓存 key
    final String id = fetcher.getId();
    EngineKey key = keyFactory.buildKey(id, signature, width, height,
        loadProvider.getCacheDecoder(), loadProvider.getSourceDecoder(),
        transformation, loadProvider.getEncoder(), transcoder,
        loadProvider.getSourceEncoder());
    // 2、根据 key 从内存中获取
    EngineResource<?> cached = getFromCache(key);
    if (cached != null) {
        cached.acquire(); // 引用计数+1
        // 放到活动资源中
        activeResources.put(key, new ResourceWeakReference(key, cached,
            resourceReferenceQueue));
        cb.onResourceReady(cached); // 回调给调用者
        return null;
    }
    // 3、从活动资源中获取（弱引用）
    WeakReference<EngineResource<?>> activeRef = activeResources.get(key);
    if (activeRef != null) {
        EngineResource<?> active = activeRef.get();
        if (active != null) { // 引用对象存在
            active.acquire(); // 引用计数+1
            cb.onResourceReady(active); // 回调给调用者
            return null;
        } else { // 引用对象不存在，从活动资源中移除
            activeResources.remove(key);
        }
    }
    // 4、从磁盘或网络或其他源头中获取
    EngineJob current = jobs.get(key);
    if (current != null) {
        current.addCallback(cb);
        return new LoadStatus(cb, current);
    }
    EngineJob engineJob = engineJobFactory.build(key, isMemoryCacheable);
    // 解码
    DecodeJob<T, Z, R> decodeJob = new DecodeJob<T, Z, R>(key, width, height,
        fetcher, loadProvider, transformation, transcoder, diskCache,
        diskCacheStrategy, priority);
    // 把 engineJob 和 decodeJob 封装到 EngingRunnable 中
    EngineRunnable runnable = new EngineRunnable(engineJob, decodeJob, priority);
    jobs.put(key, engineJob);
    engineJob.addCallback(cb);
    engineJob.start(runnable); // 开始加载（线程池 sourceService）
    return new LoadStatus(cb, engineJob);
}

@Override
public void run() {
    if (isCancelled) return; // 任务已取消，返回
    Exception exception = null;
    Resource<?> resource = null;
    try {
        resource = decode(); // 解码，会分别磁盘和源头加载
    } catch (Exception e) {
        exception = e;
    }
    if (isCancelled) {
        if (resource != null) resource.recycle(); // 任务已取消，回收资源
        return;
    }
    if (resource == null) {
        onLoadFailed(exception); // 加载失败
    } else {
        onLoadComplete(resource); // 加载完成，通过 Handler 回调到主线程
    }
}

private Resource<?> decodeFromCache() throws Exception {
    Resource<?> result = null;
    try {
        // 尝试从磁盘加载已转换过的资源
        result = decodeJob.decodeResultFromCache();
    } catch (Exception e) {}
    // 尝试从磁盘加载并转化、再次缓存到磁盘
    if (result == null) result = decodeJob.decodeSourceFromCache();
    return result;
}

private Resource<?> decodeFromSource() throws Exception {
    // 从源头获取、转码、转换并写入磁盘
    return decodeJob.decodeFromSource();
}

LinkedHashMap<String, Entry> lruEntries = new LinkedHashMap<>(0, 0.75f, true);

public Editor edit(String key) throws IOException {
    return edit(key, ANY_SEQUENCE_NUMBER);
}

private synchronized Editor edit(String key, long expectedSequenceNumber)
    throws IOException {
    checkNotClosed();
    // 根据 key 获取 entry
    Entry entry = lruEntries.get(key);
    if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER && (entry == null
        || entry.sequenceNumber != expectedSequenceNumber)) {
        return null; // Value is stale.
    }
    if (entry == null) {
        // 若 entry 为 null 则创建并加入缓存
        entry = new Entry(key);
        lruEntries.put(key, entry);
    } else if (entry.currentEditor != null) {
        return null; // Another edit is in progress.
    }
    Editor editor = new Editor(entry);
    entry.currentEditor = editor;
    // 记录日志文件
    // Flush the journal before creating files to prevent file leaks.
    journalWriter.append(DIRTY);
    journalWriter.append(' ');
    journalWriter.append(key);
    journalWriter.append('\n');
    journalWriter.flush();
    return editor;
}

public synchronized Value get(String key) throws IOException {
  checkNotClosed();
  Entry entry = lruEntries.get(key);
  if (entry == null) return null;
  if (!entry.readable) return null;
  for (File file : entry.cleanFiles) {
      // A file must have been deleted manually!
      if (!file.exists()) {
          return null;
      }
  }
  // 在日志中记录
  redundantOpCount++;
  journalWriter.append(READ);
  journalWriter.append(' ');
  journalWriter.append(key);
  journalWriter.append('\n');
  if (journalRebuildRequired()) {
      executorService.submit(cleanupCallable);
  }
  return new Value(key, entry.sequenceNumber, entry.cleanFiles, entry.lengths);
}

private void trimToSize() throws IOException {
    Map.Entry<String, Entry> toEvict;
    while (size > maxSize) {
        // 从链表头部开始移除，即移除最久未被使用的元素
        toEvict = lruEntries.entrySet().iterator().next();
        remove(toEvict.getKey());
    }
}

public synchronized boolean remove(String key) throws IOException {
    checkNotClosed();
    Entry entry = lruEntries.get(key);
    if (entry == null || entry.currentEditor != null) {
        return false;
    }
    // 删除 key 对应的所有文件
    for (int i = 0; i < valueCount; i++) {
        File file = entry.getCleanFile(i);
        if (file.exists() && !file.delete()) {
            throw new IOException("failed to delete " + file);
        }
        size -= entry.lengths[i];
        entry.lengths[i] = 0;
    }
    // 在日志中记录
    redundantOpCount++;
    journalWriter.append(REMOVE);
    journalWriter.append(' ');
    journalWriter.append(key);
    journalWriter.append('\n');
    // 从缓存中移除
    lruEntries.remove(key);
    if (journalRebuildRequired()) {
        executorService.submit(cleanupCallable);
    }
    return true;
}