@NonNull
Glide build(@NonNull Context context) {
  ...
  if (diskCacheExecutor == null) {
    diskCacheExecutor = GlideExecutor.newDiskCacheExecutor();
  }
  if (memoryCache == null) {
    memoryCache = new LruResourceCache(memorySizeCalculator.getMemoryCacheSize());
  }
  if (diskCacheFactory == null) {
    diskCacheFactory = new InternalCacheDiskCacheFactory(context);
  }
  ...
}

public synchronized <R> LoadStatus load(...) {
    long startTime = VERBOSE_IS_LOGGABLE ? LogTime.getLogTime() : 0;
    //创建了一个 EngineKey 对象，这个对象就是我们说的缓存 key ，加载资源的唯一标识,
    EngineKey key = keyFactory.buildKey(model, signature , width , height ,
 transformations , resourceClass , transcodeClass , options);
    //调用 loadFromActiveResources 方法，通过 key 获取缓存资源，此时的缓存也是内存缓存。
    EngineResource<?> active = loadFromActiveResources(key, isMemoryCacheable);
    if (active != null) {//获取到的话也直接进行回调。
      cb.onResourceReady(active, DataSource.MEMORY_CACHE);
      return null;
    }
    //如果 ActiveResources 中没有找到缓存，通过 key 查找 MemoryCache 缓存，
    //此时的缓存依旧为内存缓存，如果获取的到就直接调用cb.onResourceReady()方法进行回调。
    EngineResource<?> cached = loadFromCache(key, isMemoryCacheable);
    if (cached != null) {
      cb.onResourceReady(cached, DataSource.MEMORY_CACHE);
      return null;
    }

    //到这里，就说明内存缓存中没有进行缓存。要么是被移除了，要么是还未加载过，那么就需要去硬盘缓存中查看

    //是否可能该缓存任务正在处理，还没有完成缓存，所以根据 key 判断缓存的 job 中是否有 current ，
    EngineJob<?> current = jobs.get(key, onlyRetrieveFromCache);
    if (current != null) {
      //如果有，就不用新创建任务了，而是给其添加回调，等待完成后获取。
      current.addCallback(cb, callbackExecutor);
      return new LoadStatus(cb, current);
    }
    //需要创建新的加载任务。并把当前任务存放在 jobs 这个 map 中。同时要开启线程来加载新的图片了。
    EngineJob<R> engineJob = engineJobFactory.build(...);
    DecodeJob<R> decodeJob = decodeJobFactory.build(...);
    //把创建的 加载任务和 key 放到 joes 中，这样避免加载多次
    jobs.put(key, engineJob);

    engineJob.addCallback(cb, callbackExecutor);
    engineJob.start(decodeJob);
    return new LoadStatus(cb, engineJob);
  }

EngineKey key = keyFactory.buildKey(model, signature , width , height , transformations ,
 resourceClass , transcodeClass , options);
//生成 EngineKey 很严格，
EngineKey buildKey(Object model, Key signature , int width , int height ,
     Map<Class<?>, Transformation<?>> transformations, Class<?> resourceClass,
     Class<?> transcodeClass, Options options) {
   return new EngineKey(model, signature , width , height , transformations , resourceClass ,
 transcodeClass , options);
 }        

private EngineResource<?> loadFromActiveResources(Key key, boolean isMemoryCacheable) {
    //isMemoryCacheable 内存缓存是否被开启， Glide 默认为true
    if (!isMemoryCacheable) {
      return null;
    }
    //根据缓存 key 查找是否存在 activeResources ，
    EngineResource<?> active = activeResources.get(key);
    if (active != null) {
      //存在，引用值加1
      active.acquire();
    }
    return active;
  }

final class ActiveResources {
  final Map<Key, ResourceWeakReference> activeEngineResources = new HashMap<>();
  private final ReferenceQueue<EngineResource<?>> resourceReferenceQueue = new ReferenceQueue<>();

    @Nullable
    synchronized EngineResource<?> get(Key key) {
      ResourceWeakReference activeRef = activeEngineResources.get(key);
      if (activeRef == null) {
        return null;
      }
      EngineResource<?> active = activeRef.get();
      if (active == null) {
        cleanupActiveReference(activeRef);
      }
      return active;
    }
  }

//ResourceWeakReference 是一个 WeakReference 的子类,也就是一个弱引用类型，存放的对象就是 EngineResource
static final class ResourceWeakReference extends WeakReference<EngineResource<?>> {
}

Glide.with(this)
  .load(url)
  // 不忽略内存缓存，即启用
  .apply(RequestOptions.skipMemoryCacheOf(false))
  .into(view);

//内存缓存 (Memory cache) - 该图片是否最近被加载过并仍存在于内存中？
private EngineResource<?> loadFromCache(Key key, boolean isMemoryCacheable) {
  //内存缓存是否被开启，默认是开启
  if (!isMemoryCacheable) {
    return null;
  }
  //使用缓存 Key 来从 cache 当中取值
  EngineResource<?> cached = getEngineResourceFromCache(key);
  if (cached != null) {//
    //调用 acquire() 方法会让变量 acquire 加 1 ，用来记录图片被引用的次数，
    cached.acquire();
    //将这个缓存图片存储到 activeResources 当中, activeResources 就是一个弱引用的 HashMap ，用来缓存正在使用中的图片
    activeResources.activate(key, cached);
  }
  return cached;
}

private final MemoryCache cache;

private EngineResource<?> getEngineResourceFromCache(Key key) {
  Resource<?> cached = cache.remove(key);
  final EngineResource<?> result;
  if (cached == null) {
    result = null;
  } else if (cached instanceof EngineResource) {
    result = (EngineResource<?>) cached;
  } else {
    result = new EngineResource<>(cached, true /*isMemoryCacheable*/, true /*isRecyclable*/);
  }
  return result;
}

GlideApp.with(fragment)
  .load(url)
  //禁用磁盘缓存
  .diskCacheStrategy(DiskCacheStrategy.NONE)
  .into(view);

//EngineJob.java
public synchronized void start(DecodeJob<R> decodeJob) {
   this.decodeJob = decodeJob;
   GlideExecutor executor = decodeJob.willDecodeFromCache() ? diskCacheExecutor: getActiveSourceExecutor();
   executor.execute(decodeJob);
 }

//DecodeJob.java
boolean willDecodeFromCache() {
   Stage firstStage = getNextStage(Stage.INITIALIZE);
   return firstStage == Stage.RESOURCE_CACHE || firstStage == Stage.DATA_CACHE;
 }

private Stage getNextStage(Stage current) {
  switch (current) {
    case INITIALIZE:
    //如果我们指定磁盘缓存策略为 ALL 或 RESOURCE 或由 AUTOMATIC 对远程图片使用磁盘缓存时，此时返回 true ,返回Stage.RESOURCE_CACHE。
    //如果为 false ，递归调用，判断是否为diskCacheStrategy.decodeCachedData()，也就是指定磁盘缓存策略为 ALL 或DATA
      return diskCacheStrategy.decodeCachedResource()? Stage.RESOURCE_CACHE : getNextStage(Stage.RESOURCE_CACHE);
    case RESOURCE_CACHE:
    //是否解码缓存的原始数据，就是指缓存的未做过变换的数据
      return diskCacheStrategy.decodeCachedData() ? Stage.DATA_CACHE : getNextStage(Stage.DATA_CACHE);
    case DATA_CACHE:
      //判断 onlyRetrieveFromCache ，这个值是初始化 DecodeJob 中传进来的，它代表是否仅从缓存加载图片，通过onlyRetrieveFromCache(true)制定,默认为 false
      //如果为 true ，它意味着要从内存或磁盘读取，如果内存或磁盘不存在该资源，则加载直接失败。一般情况下我们不会制定，为 false ，也就是会返回 Stage.SOURCE。代表不使用磁盘缓存，也就是之前文章分析的，直接从服务器下载
      return onlyRetrieveFromCache ? Stage.FINISHED : Stage.SOURCE;
    case SOURCE:
    case FINISHED:
      return Stage.FINISHED;
    default:
      throw new IllegalArgumentException("Unrecognized stage: " + current);
  }
}

//DecodeJob.java
private void runWrapped() {
  switch (runReason) {
    case INITIALIZE:
      // 初始化 获取下一个阶段状态
      stage = getNextStage(Stage.INITIALIZE);
      currentGenerator = getNextGenerator();
      // 运行
      runGenerators();
      break;
    case SWITCH_TO_SOURCE_SERVICE:
      runGenerators();
      break;
    case DECODE_DATA:
      decodeFromRetrievedData();
      break;
    default:
      throw new IllegalStateException("Unrecognized run reason: " + runReason);
  }
}

private Stage getNextStage(Stage current) {
  switch (current) {
    case INITIALIZE:
    //是否解码缓存的转换图片，就是只做过变换之后的缓存数据
    return diskCacheStrategy.decodeCachedResource()? Stage.RESOURCE_CACHE : getNextStage(Stage.RESOURCE_CACHE);
    ...
  }
}      

private DataFetcherGenerator getNextGenerator() {
  switch (stage) {
    case RESOURCE_CACHE:
      return new ResourceCacheGenerator(decodeHelper, this);
    case DATA_CACHE:
      return new DataCacheGenerator(decodeHelper, this);
    case SOURCE:
      return new SourceGenerator(decodeHelper, this);
    case FINISHED:
      return null;
    default:
      throw new IllegalStateException("Unrecognized stage: " + stage);
  }
}

private void runGenerators() {
  currentThread = Thread.currentThread();
  startFetchTime = LogTime.getLogTime();
  boolean isStarted = false;
  while (!isCancelled && currentGenerator != null && !(isStarted = )) {
    stage = getNextStage(stage);
    currentGenerator = getNextGenerator();

    if (stage == Stage.SOURCE) {
      reschedule();
      return;
    }
  }
  if ((stage == Stage.FINISHED || isCancelled) && !isStarted) {
    notifyFailed();
  }
}

//ResourceCacheGenerator.java
public boolean startNext() {
      ...
      // 1 构建获取缓存信息的键
      currentKey = new ResourceCacheKey(...);
      // 2 从缓存中获取缓存信息
      cacheFile = helper.getDiskCache().get(currentKey);
      if (cacheFile != null) {
        sourceKey = sourceId;
        modelLoaders = helper.getModelLoaders(cacheFile);
        modelLoaderIndex = 0;
      }
    }

    loadData = null;
    boolean started = false;
    // 查找ModelLoader
    while (!started && hasNextModelLoader()) {
      ModelLoader<File, ?> modelLoader = modelLoaders.get(modelLoaderIndex++);
      //根据 key 读取缓存文件 cacheFile ，传入 File ，
      loadData = modelLoader.buildLoadData(cacheFile, helper.getWidth(), helper.getHeight(), helper.getOptions());
      if (loadData != null && helper.hasLoadPath(loadData.fetcher.getDataClass())) {
        started = true;
        // 通过 FileLoader 继续加载数据
        loadData.fetcher.loadData(helper.getPriority(), this);
      }
    }
    return started;
  }

//FileFetcher.java
public void loadData(@NonNull Priority priority, @NonNull DataCallback<? super Data> callback) {
  try {
    data = opener.open(file);
  } catch (FileNotFoundException e) {
    callback.onLoadFailed(e);
    return;
  }
  //返回结果,
  callback.onDataReady(data);
}

//DecodeJob.java
public void onDataFetcherReady(Key sourceKey, Object data , DataFetcher<?> fetcher, DataSource dataSource , Key attemptedKey) {
  ...
  if (Thread.currentThread() != currentThread) {
    runReason = RunReason.DECODE_DATA;
    callback.reschedule(this);
  } else {
    GlideTrace.beginSection("DecodeJob.decodeFromRetrievedData");
    try {
      decodeFromRetrievedData();
    } finally {
      GlideTrace.endSection();
    }
  }
}

private void decodeFromRetrievedData() {
  Resource<R> resource = null;
  try {
    //将数据解码成 Resource 对象
    resource = decodeFromData(currentFetcher, currentData , currentDataSource);
  } catch (GlideException e) {
    e.setLoggingDetails(currentAttemptingKey, currentDataSource);
    throwables.add(e);
  }
  if (resource != null) {
    //回调 UI 线程显示出来。
    notifyEncodeAndRelease(resource, currentDataSource);
  } else {
    //如果 ResourceCache 中没有，则进行递归调用，生成下一个 Generator ,继续查找
    runGenerators();
  }
}

private Stage getNextStage(Stage current) {
  switch (current) {
    case INITIALIZE:
      return diskCacheStrategy.decodeCachedResource()? Stage.RESOURCE_CACHE : getNextStage(Stage.RESOURCE_CACHE);
    case RESOURCE_CACHE:
      return diskCacheStrategy.decodeCachedData() ? Stage.DATA_CACHE : getNextStage(Stage.DATA_CACHE);
      ...
  }
}

public static final DiskCacheStrategy ALL = new DiskCacheStrategy() {
     public boolean decodeCachedData() {
         return true;
     }
 };
 public static final DiskCacheStrategy DATA = new DiskCacheStrategy() {
       public boolean decodeCachedData() {
           return true;
       }
   };
  public static final DiskCacheStrategy AUTOMATIC = new DiskCacheStrategy() {
     public boolean decodeCachedData() {
         return true;
     }
  };

public boolean startNext() {
  while (modelLoaders == null || !hasNextModelLoader()) {
    sourceIdIndex++;
    if (sourceIdIndex >= cacheKeys.size()) {
      return false;
    }

    Key sourceId = cacheKeys.get(sourceIdIndex);
    Key originalKey = new DataCacheKey(sourceId, helper.getSignature());
    cacheFile = helper.getDiskCache().get(originalKey);
    if (cacheFile != null) {
      this.sourceKey = sourceId;
      modelLoaders = helper.getModelLoaders(cacheFile);
      modelLoaderIndex = 0;
    }
  }

  loadData = null;
  boolean started = false;
  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;
}

private Stage getNextStage(Stage current) {
  ...
    case DATA_CACHE:
      return onlyRetrieveFromCache ? Stage.FINISHED : Stage.SOURCE;
    case SOURCE:
    case FINISHED:
      return Stage.FINISHED;
    ...
  }
}

public boolean startNext() {
   if (dataToCache != null) {
     Object data = dataToCache;
     dataToCache = null;
     cacheData(data);
   }
   //正在执行 startNext ，则直接返回
   if (sourceCacheGenerator != null && sourceCacheGenerator.startNext()) {
     return true;
   }
   sourceCacheGenerator = null;

   loadData = null;
   boolean started = false;
   while (!started && hasNextModelLoader()) {
     loadData = helper.getLoadData().get(loadDataListIndex++);
     if (loadData != null && (helper.getDiskCacheStrategy().isDataCacheable(loadData.fetcher.getDataSource())|| helper.hasLoadPath(loadData.fetcher.getDataClass()))) {
       started = true;
       loadData.fetcher.loadData(helper.getPriority(), this);
     }
   }
   return started;
 }

//SourceGenerator类
@Override
  public void onDataReady(Object data) {
    DiskCacheStrategy diskCacheStrategy = helper.getDiskCacheStrategy();
    if (data != null && diskCacheStrategy.isDataCacheable(loadData.fetcher.getDataSource())) {
      dataToCache = data;
      cb.reschedule();
    } else {
      cb.onDataFetcherReady(loadData.sourceKey, data , loadData.fetcher,loadData.fetcher.getDataSource(), originalKey);
    }
  }

//SourceGenerator.java
 public boolean startNext() {
   // 这个时候 dataToCache 不为 null ，所以执行 cacheData() ,进行缓存
   if (dataToCache != null) {
     Object data = dataToCache;
     dataToCache = null;
     cacheData(data);
   }
   if (sourceCacheGenerator != null && sourceCacheGenerator.startNext()) {
     return true;
   }
   ...
 }

private void cacheData(Object dataToCache) {
  long startTime = LogTime.getLogTime();
  try {
    // 根据不同的数据获取注册的不同Encoder
    Encoder<Object> encoder = helper.getSourceEncoder(dataToCache);
    DataCacheWriter<Object> writer = new DataCacheWriter<>(encoder, dataToCache , helper.getOptions());
    originalKey = new DataCacheKey(loadData.sourceKey, helper.getSignature());
    //得到 DiskCache 得实现，并存入磁盘。
    helper.getDiskCache().put(originalKey, writer);
    }
  } finally {
    loadData.fetcher.cleanup();
  }
  sourceCacheGenerator = new DataCacheGenerator(Collections.singletonList(loadData.sourceKey), helper , this);
}

//EngineJob.java
public void onResourceReady(Resource<R> resource, DataSource dataSource) {
  synchronized (this) {
    this.resource = resource;
    this.dataSource = dataSource;
  }
  notifyCallbacksOfResult();
}

void notifyCallbacksOfResult() {
    ...
    //listener 就是 Engine
    listener.onEngineJobComplete(this, localKey , localResource);
    for (final ResourceCallbackAndExecutor entry : copy) {
      // 在这里，会去加载数据，显示到 UI 上
      entry.executor.execute(new CallResourceReady(entry.cb));
    }
    decrementPendingCallbacks();
  }

//Engine.java
public synchronized void onEngineJobComplete( EngineJob<?> engineJob, Key key , EngineResource<?> resource) {
  if (resource != null) {
    //将 resource 添加监听
    resource.setResourceListener(key, this);
    //回调过来的 EngineResource 被 put 到了 activeResources 当中，在这里写入到了内存缓存的弱引用缓存。
    //写入到弱引用缓存的原因是这个资源是属于正在被加载展示的资源，也就是正在被使用的资源。
    if (resource.isCacheable()) {
      activeResources.activate(key, resource);
    }
  }
  jobs.removeIfCurrent(key, engineJob);
}

//ActiveResources.java
synchronized void activate(Key key, EngineResource<?> resource) {
  // 根据 缓存 key , resource 等创建一个 ResourceWeakReference ,
  ResourceWeakReference toPut =
      new ResourceWeakReference(key, resource , resourceReferenceQueue , isActiveResourceRetentionAllowed);
    // 把这个放入到 activeEngineResources map 集合，返回的是之前存放的
  ResourceWeakReference removed = activeEngineResources.put(key, toPut);
  if (removed != null) {
    //如果这个缓存 key 之前存放的有 ResourceWeakReference ,则重置这个 ResourceWeakReference ，
    removed.reset();
  }
}

//EngineResource.java
synchronized void acquire() {
  if (isRecycled) {
    throw new IllegalStateException("Cannot acquire a recycled resource");
  }
  ++acquired;
}

void release() {
  synchronized (listener) {
    synchronized (this) {
      if (acquired <= 0) {
        throw new IllegalStateException("Cannot release a recycled or not yet acquired resource");
      }
      if (--acquired == 0) {
        listener.onResourceReleased(key, this);
      }
    }
  }
}

//Engine.java
public synchronized void onResourceReleased(Key cacheKey, EngineResource<?> resource) {
  //当不在使用中时，此时就可以从 activeResources 移除，同时就可以添加到 Lrucache 中了。此处为写入内存缓存的 LruCache 地方。
   activeResources.deactivate(cacheKey);
   if (resource.isCacheable()) {
     cache.put(cacheKey, resource);
   } else {
     resourceRecycler.recycle(resource);
   }
 }