Glide缓存原理

glide缓存分为内存缓存和磁盘缓存。内存缓存分为活动缓存和cache。磁盘缓存又分为resource和data。本文将围绕加载图片流程介绍glide的缓存。

 Glide.with(this)
          .load(url)
           .skipMemoryCache(true)
            // .transform(CircleCrop())
           // .error(R.drawable.ic_launcher_background)
          .diskCacheStrategy(DiskCacheStrategy.NONE)
          .listener(getListener(index))
          .into(mIv)

1、load

public <R> LoadStatus load(
      GlideContext glideContext,
      Object model) {
    long startTime = VERBOSE_IS_LOGGABLE ? LogTime.getLogTime() : 0;

    EngineKey key =
        keyFactory.buildKey(
            model,
            signature,
            width,
            height);

    EngineResource<?> memoryResource;
    synchronized (this) {
      memoryResource = loadFromMemory(key, isMemoryCacheable, startTime);

      if (memoryResource == null) {
        return waitForExistingOrStartNewJob(
            glideContext,
            model,
            signature,
            width,
            height);
      }
    }
  cb.onResourceReady(
        memoryResource, DataSource.MEMORY_CACHE, /* isLoadedFromAlternateCacheKey= */ false);
    return null;
  }

1.1、loadFromMemory 先从内从中加载。

//Engine
private EngineResource<?> loadFromMemory(
            EngineKey key, boolean isMemoryCacheable, long startTime) {

        if (!isMemoryCacheable) {
           return null;
         }

        EngineResource<?> active = loadFromActiveResources(key);
        if (active != null) {
            return active;
        }
        EngineResource<?> cached = loadFromCache(key);
        if (cached != null) {
            return cached;
        }
        return null;
    }

可以看到从内存加载又分为活动缓存和 cache
1.11、活动缓存
举例： 一个LinearLayout中有10个imageview，通过glide加载。那么这10个图片就缓存在activityResource中。 当点击的条目，删除一个item. 这个ActivityResource缓存并没有被移除。当gc运行时，将这个item回收掉之后了，就会将这个缓存加入到resourceReferenceQueue，然后通过遍历这个引用队列，从活动缓存中移除。
举例： 当在recyclerview的每个item加载一个imagview。 那么这个活动缓存的最大数目为= 可见数据+ 预加载数目 + 复用池1 ，因为从recyclerview移除之后，不一定就被立即回收了，当从复用池中复用item时，会主动释放上一次item对应的活动缓存。此时活动缓存就减少了。
活动缓存是何时存入的了？
1)、从缓存中获取到资源时，加入到活动缓存。

 private EngineResource<?> loadFromCache(Key key) {
    EngineResource<?> cached = getEngineResourceFromCache(key);
    if (cached != null) {
      cached.acquire();
      activeResources.activate(key, cached);
    }
    return cached;
  }

2)、从网络和磁盘加载资源完成时，加入到活动缓存。
活动缓存何时删除的了？
1）、onDestroy时，request调用clear() 会释放当前对应key的活动缓存。
2）、不能设置资源给target，释放当前key的活动缓存。
3）、获取活动缓存，发现该活动缓存EngineResource不存在，就删除key的活动缓存。也就是setIsActiveResourceRetentionAllowed(false)的情况。
4)、创建ActiveResources对象时，就开启了一个线程，一直轮询这个queue，如果存在的EngineResource，就删除对应的活动缓存。
1.12、内存缓存
获取内存时就从内存缓存中移除。

//Engine
 private EngineResource<?> getEngineResourceFromCache(Key key) {
    Resource<?> cached = cache.remove(key);
    final EngineResource<?> result;
    if (cached == null) {
      result = null;
    } else if (cached instanceof EngineResource) {
      // Save an object allocation if we've cached an EngineResource (the typical case).
      result = (EngineResource<?>) cached;
    } else {
      result =
          new EngineResource<>(
              cached,
              /* isMemoryCacheable= */ true,
              /* isRecyclable= */ true,
              key,
              /* listener= */ this);
    }
    return result;
  }

何时加入内存
从活动缓存移除就加入了内存缓存。内存缓存超过容量后被释放的bitmap等会被加入到bitmapPool中。从活动缓存中移除的要么加入内存缓存，要么加入到bitmapPool中。

//Engine
public void onResourceReleased(Key cacheKey, EngineResource<?> resource) {
    activeResources.deactivate(cacheKey);
    if (resource.isMemoryCacheable()) {
     //加入内存缓存
      cache.put(cacheKey, resource);
    } else {
   //资源释放，bitmap支持复用则加入到bitmapPool
      resourceRecycler.recycle(resource, /* forceNextFrame= */ false);
    }
  }


//BitmapResource
@Override
  public void recycle() {
    bitmapPool.put(bitmap);
  }

缓存资源的key是通过宽高,加载图片的model、options等生成的。所以宽高变化，可能导致内存中找不到这张图。
1.2、内存不存在，开启一个job从网络加载加载。

  private <R> Engine.LoadStatus waitForExistingOrStartNewJob(
            GlideContext glideContext,
            Object model,
            Key signature,
            int width,
            int height) {

        EngineJob<?> current = jobs.get(key, onlyRetrieveFromCache);
        if (current != null) {
            current.addCallback(cb, callbackExecutor);
            return new Engine.LoadStatus(cb, current);
        }

        EngineJob<R> engineJob =
                engineJobFactory.build(
                        key,
                        isMemoryCacheable,
                        useUnlimitedSourceExecutorPool,
                        useAnimationPool,
                        onlyRetrieveFromCache);

        DecodeJob<R> decodeJob =
                decodeJobFactory.build(
                        glideContext,
                        model,
                        key,
                        signature,
                        width,
                        height,
                        engineJob);
        jobs.put(key, engineJob);
        engineJob.addCallback(cb, callbackExecutor);
        engineJob.start(decodeJob);
        return new Engine.LoadStatus(cb, engineJob);
    }

可以看到先判断，是否是从从缓存中取获取缓存job。
如果缓存的job没有找到。则创建一个job。并且执行这个RunableJob。

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

所以接下来，我们看下这个runnable（DecodeJob)的run方法。

 public void run() {
        DataFetcher<?> localFetcher = currentFetcher;
        try {
            runWrapped();
        }
    }

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

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

 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);
      case DATA_CACHE:
        // Skip loading from source if the user opted to only retrieve the resource from cache.
        return onlyRetrieveFromCache ? Stage.FINISHED : Stage.SOURCE;
      case SOURCE:
      case FINISHED:
        return Stage.FINISHED;
  }

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

可以看到，根据当前的状态和diskCacheStrategy磁盘策略的配置，来决定是加载RESOURCE_CACHE、DATA_CACHE、SOURCE。
RESOURCE_CACHE ： 是转换过或者改变过采样率的文件。解码之后的。
DATA_CACHE：原始的未修改的数据。解码之前的。
SOURCE ：网络文件，源文件。
1.3、INITIALIZE
如果配置全部允许，会首先去加载Resource_cache，再加载DATA_CACHE，如果都加载不了，再从网络加载SOURCE。
ResourceCacheGenerator和DataCacheGenerator会从磁盘缓存中加载数据，这里不看了，看下从Remote加载，SourceGenerator从网络加载数据。

// SourceGenerator
public boolean startNext() {
        if (dataToCache != null) {
            Object data = dataToCache;
            boolean isDataInCache = cacheData(data);
            dataToCache = null;
        }
        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;
                startNextLoad(loadData);
            }
        }
        return started;
    }

    private void startNextLoad(final ModelLoader.LoadData<?> toStart) {
        loadData.fetcher.loadData(
                helper.getPriority(),
                new DataFetcher.DataCallback<Object>() {
                    @Override
                    public void onDataReady(@Nullable Object data) {
                        if (isCurrentRequest(toStart)) {
                            onDataReadyInternal(toStart, data);
                        }
                    }

                    @Override
                    public void onLoadFailed(@NonNull Exception e) {
                        if (isCurrentRequest(toStart)) {
                            onLoadFailedInternal(toStart, e);
                        }
                    }
                });
    }

  void onDataReadyInternal(LoadData<?> loadData, 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);
    }
  }

首先从网络loadData.fetcher.loadData中加载，然后判断isDataCacheable()是否可以缓存data，这个配置是缓存策略中配置的。如果可以缓存，调用cb.reschedule()。
1.4、SWITCH_TO_SOURCE_SERVICE

  private void reschedule(RunReason runReason) {
    this.runReason = runReason;
    callback.reschedule(this);
  }

  @Override
  public void reschedule() {
    reschedule(RunReason.SWITCH_TO_SOURCE_SERVICE);
  }

这个方法会再次调用run()方法，状态变为SWITCH_TO_SOURCE_SERVICE从网络获取数据切换到从磁盘获取， 还会再次执行要这个类。 此时startNext方法中的dataToCache不为空，并且会调用将数据缓存到磁盘中，然后调用DataCacheGenerator.startNext()，调用磁盘缓存加载，返回磁盘加载的结果。

// SourceGenerator
 private boolean cacheData(Object dataToCache) throws IOException {
        try {
            DataRewinder<Object> rewinder = helper.getRewinder(dataToCache);
            Object data = rewinder.rewindAndGet();
            Encoder<Object> encoder = helper.getSourceEncoder(data);
            DataCacheWriter<Object> writer = new DataCacheWriter<>(encoder, data, helper.getOptions());
            DataCacheKey newOriginalKey = new DataCacheKey(loadData.sourceKey, helper.getSignature());
            DiskCache diskCache = helper.getDiskCache();
            diskCache.put(newOriginalKey, writer);

            if (diskCache.get(newOriginalKey) != null) {
                originalKey = newOriginalKey;
                sourceCacheGenerator =
                        new DataCacheGenerator(Collections.singletonList(loadData.sourceKey), helper, this);
                return true;
            } else {
                cb.onDataFetcherReady(
                        loadData.sourceKey,
                        rewinder.rewindAndGet(),
                        loadData.fetcher,
                        loadData.fetcher.getDataSource(),
                        loadData.sourceKey);
            }
            return false;
        }
    }

上面就是在SourceGenerator中缓存数据Stream到磁盘过程。
1.5、DECODE_DATA
从getNextStage分析完INITIALIZE、SWITCH_TO_SOURCE_SERVICE，接下看下DECODE_DATA状态，从网络请求对应的HttpGlideUrlLoader，返回的输入流数据是ContentLengthInputStream。
从磁盘缓存对应的FileLoader，返回的输入流是文件输入流。
对于这些流需要转化成Bitmap、Drawable等。
decode的过程 就是将InputStream 转化成bitmap的过程。

//DecodeJob
 private void decodeFromRetrievedData() {
    Resource<R> resource = null;
    try {
      resource = decodeFromData(currentFetcher, currentData, currentDataSource);
    } catch (GlideException e) {
    }
    if (resource != null) {
      notifyEncodeAndRelease(resource, currentDataSource, isLoadingFromAlternateCacheKey);
    } else {
      runGenerators();
    }
  }
 //DecodePath 
 public Resource<Transcode> decode(
      DataRewinder<DataType> rewinder,
      int width,
      int height,
      @NonNull Options options,
      DecodeCallback<ResourceType> callback)
      throws GlideException {
    Resource<ResourceType> decoded = decodeResource(rewinder, width, height, options);
    Resource<ResourceType> transformed = callback.onResourceDecoded(decoded);
    return transcoder.transcode(transformed, options);
  }

//DecodeJob
<Z> Resource<Z> onResourceDecoded(DataSource dataSource, @NonNull Resource<Z> decoded) {
    @SuppressWarnings("unchecked")
    Class<Z> resourceSubClass = (Class<Z>) decoded.get().getClass();
    Transformation<Z> appliedTransformation = null;
    Resource<Z> transformed = decoded;
    if (dataSource != DataSource.RESOURCE_DISK_CACHE) {
      appliedTransformation = decodeHelper.getTransformation(resourceSubClass);
      transformed = appliedTransformation.transform(glideContext, decoded, width, height);
    }

    final EncodeStrategy encodeStrategy;
    final ResourceEncoder<Z> encoder;
    if (decodeHelper.isResourceEncoderAvailable(transformed)) {
      encoder = decodeHelper.getResultEncoder(transformed);
      encodeStrategy = encoder.getEncodeStrategy(options);
    } else {
      encoder = null;
      encodeStrategy = EncodeStrategy.NONE;
    }

    Resource<Z> result = transformed;
    boolean isFromAlternateCacheKey = !decodeHelper.isSourceKey(currentSourceKey);
    if (diskCacheStrategy.isResourceCacheable(
        isFromAlternateCacheKey, dataSource, encodeStrategy)) {
      final Key key;
      switch (encodeStrategy) {
        case SOURCE:
          key = new DataCacheKey(currentSourceKey, signature);
          break;
        case TRANSFORMED:
          key =
              new ResourceCacheKey(
                  decodeHelper.getArrayPool(),
                  currentSourceKey,
                  signature,
                  width,
                  height,
                  appliedTransformation,
                  resourceSubClass,
                  options);
          break;
        default:
          throw new IllegalArgumentException("Unknown strategy: " + encodeStrategy);
      }

      LockedResource<Z> lockedResult = LockedResource.obtain(transformed);
      deferredEncodeManager.init(key, encoder, lockedResult);
      result = lockedResult;
    }
    return result;
  }

上面第一步是decode的流程，将stream转化成bitmap，设置采样率等，transformed，可以看到在解析完成调用了diskCacheStrategy.isResourceCacheable()这个方法主要是为了初始化Resouce_cache相关信息。

// DecodeJob
private void notifyEncodeAndRelease(
      Resource<R> resource, DataSource dataSource, boolean isLoadedFromAlternateCacheKey) {
    GlideTrace.beginSection("DecodeJob.notifyEncodeAndRelease");
    try {
      Resource<R> result = resource;
      LockedResource<R> lockedResource = null;
      if (deferredEncodeManager.hasResourceToEncode()) {
        lockedResource = LockedResource.obtain(resource);
        result = lockedResource;
      }
      notifyComplete(result, dataSource, isLoadedFromAlternateCacheKey)
      stage = Stage.ENCODE;
      try {
        if (deferredEncodeManager.hasResourceToEncode()) {
          deferredEncodeManager.encode(diskCacheProvider, options);
        }
      } finally {
      onEncodeComplete();
    } finally {
      GlideTrace.endSection();
    }
  }

private void notifyComplete(
      Resource<R> resource, DataSource dataSource, boolean isLoadedFromAlternateCacheKey) {
    setNotifiedOrThrow();
    callback.onResourceReady(resource, dataSource, isLoadedFromAlternateCacheKey);
  }

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

notifyComplete就是调用callback.onResourceReady这个方法最终就回调到我们给request设置的RequestListener中。
上面我们知道缓存Resource相关key已经初始化了，接着deferredEncodeManager.encode将resource缓存在本地，整个加载过程就结束。
上面我们一直提到磁盘缓存策略，那么我们看一下DiskCacheStrategy.ALL的代码.

 public static final DiskCacheStrategy ALL =
      new DiskCacheStrategy() {
        @Override
        public boolean isDataCacheable(DataSource dataSource) {
          return dataSource == DataSource.REMOTE;
        }

        @Override
        public boolean isResourceCacheable(
            boolean isFromAlternateCacheKey, DataSource dataSource, EncodeStrategy encodeStrategy) {
          return dataSource != DataSource.RESOURCE_DISK_CACHE
              && dataSource != DataSource.MEMORY_CACHE;
        }

        @Override
        public boolean decodeCachedResource() {
          return true;
        }

        @Override
        public boolean decodeCachedData() {
          return true;
        }
      };

isDataCacheable 表示可以将原始数据data缓存。
isResourceCacheable 表示可以将Resouce数据缓存。
decodeCachedResource 表示可以从Resource 中加载数据。
decodeCachedData 表示可以从Data中加载数据。

image.png

上面这幅图展示了glide缓存加载流程，没有BitmapPool，BitmapPool 只是从磁盘缓存、网络加载图片时，decode图片需要复用的之前图片的内存，从bitmappool中获取。 活动内存释放、cache的大小超过了容量会加入到bitmapPool。