Detailed explanation of the Glide cache mechanism principle for advanced Android source code

[[420787]]

This article is reprinted from the WeChat public account "Android Development Programming", the author is Android Development Programming. Please contact the Android Development Programming public account for reprinting this article.

Preface

Android cache mechanism: If there is no cache, a large number of network requests will cause a waste of network traffic when obtaining images from remote locations, resulting in slow loading speed and poor user experience;

Today we will talk about Glide's caching mechanism

1. Brief Introduction of Cache Concept in Glide

Glide divides it into two modules, one is memory cache and the other is hard disk cache;

1. Memory Cache

The memory cache is divided into two levels, the first level is LruCache cache, and the second level is weak reference cache

The purpose of memory cache is to prevent the application from repeatedly reading image data into memory.

LruCache: Images that are not in use are cached using LruCache.

Weak reference cache: Use weak references to cache images in use. This protects the resources in use from being recycled by the LruCache algorithm.

2. Hard disk cache

The role of hard disk cache: prevent applications from repeatedly downloading and reading data from the network or other places;

3. Image request steps

Before starting a new image request, check the following cache levels:

Memory cache: Has the image been loaded recently and is it still in memory? That is, LruCache cache;

Active resources: Is there another View currently displaying this image? That is, weak reference cache;

Resource Type: Has the image been previously decoded, converted, and written to disk cache?

Data source: Has the resource used to construct this image been written to the file cache before?

The first two steps check if the image is in memory, and if so, return the image directly. The second two steps check if the image is on disk, so that the image can be returned quickly but asynchronously;

If the image cannot be found in any of the four steps, Glide returns to the original resource to retrieve the data (original file, Uri, Url, etc.);

The order in which images are stored is: weak reference, memory, disk;

The order in which images are retrieved is: memory, weak reference, disk.

4. Bitmap reuse mechanism in Glide

Bitmap reuse mechanism: reuse the data space that is no longer needed to reduce memory jitter (the phenomenon that a large number of objects are created or recycled in a short period of time);

BitmapFactory.Options.inMutable is the cornerstone of Glide's ability to reuse Bitmaps. It is a parameter provided by BitmapFactory, indicating that the Bitmap is mutable and supports reuse. BitmapFactory.Options provides two properties: inMutable and inBitmap. When reusing Bitmaps, you need to set inMutable to true, and inBitmap sets the existing Bitmap to be reused. The Bitmap reuse pool is implemented using the LRU algorithm.

2. Cache source code process

The memory cache and disk cache are also created when Glide is created. The code created by Glide is in the GlideBuilder.build(Context) method.

 @NonNull
 Glide build(@NonNull Context context) {
 if (memoryCache == null ) {
    memoryCache = new LruResourceCache(memorySizeCalculator.getMemoryCacheSize());
 }
  if (diskCacheFactory == null ) {
    diskCacheFactory = new InternalCacheDiskCacheFactory(context);
 }
 if (engine == null ) {
 engine =
 new Engine(
 memoryCache,
 diskCacheFactory,
 ...);
 }
 return new Glide(
 ...
 memoryCache,
 ...);
 }

1. Memory Cache-memoryCache

From the code, we can see that memoryCache is put into Engine and Glide instances. In Engine, memoryCache is used for access operations. The memoryCache in the Glide instance is used to notify memoryCache to release memory when memory is tight. Glide implements the ComponentCallbacks2 interface. After Glide is created, the Glide instance can listen to the signal of memory tightness through applicationContext.registerComponentCallbacks(glide).

 // Glide
 @Override
 public void onTrimMemory( int   level ) {
 trimMemory( level );
 }
 public void trimMemory( int   level ) {
  // Engine asserts this anyway when removing resources, fail faster and consistently
 Util.assertMainThread();
  // memory cache needs to be trimmed before bitmap pool to trim re-pooled Bitmaps too. See #687.
  memoryCache.trimMemory( level );
  bitmapPool.trimMemory( level );
  arrayPool.trimMemory( level );
 }

memoryCache is a memory cache class LruResourceCache that uses the LRU (least recently used) algorithm. It inherits from the LruCache class and implements the MemoryCache interface. LruCache defines operations related to the LRU algorithm implementation, while MemoryCache defines operations related to memory caching.

The implementation of LruCache utilizes a feature of the LinkedHashMap data structure (accessOrder=true based on access order) and implements a caching strategy by locking the data operations of LinkedHashMap.

When the put() method is called, an element is added to the collection and the

trimToSize() determines whether the cache is full. If it is full, it uses the LinkedHashMap iterator to delete the tail element, that is, the element that has been least recently accessed.

When the get() method is called to access the cache object, the LinkedHashMap's get() method is called to obtain the corresponding collection element, and the element is updated to the head of the queue.

2. Disk Cache

diskCacheFactory is a Factory for creating DiskCache, which defines the DiskCache interface.

 public interface DiskCache {
 interface Factory {
 /** 250 MB of cache. */
 int DEFAULT_DISK_CACHE_SIZE = 250 * 1024 * 1024;
    String DEFAULT_DISK_CACHE_DIR = "image_manager_disk_cache" ;
 @Nullable
 DiskCache build();
 }
 interface Writer {
    boolean write(@NonNull File file);
 }
 @Nullable
 File get( Key   key );
 void put( Key   key , Writer writer);
  @SuppressWarnings( "unused" )
 void delete ( Key   key );
 void clear();
 }

Next, let's take a look at the default implementation of DiskCache.Factory: InternalCacheDiskCacheFactory.

 public final class InternalCacheDiskCacheFactory extends DiskLruCacheFactory {
 public InternalCacheDiskCacheFactory(Context context) {
    this(context, DiskCache.Factory.DEFAULT_DISK_CACHE_DIR,
        DiskCache.Factory.DEFAULT_DISK_CACHE_SIZE);
 }
 public InternalCacheDiskCacheFactory(Context context, long diskCacheSize) {
    this(context, DiskCache.Factory.DEFAULT_DISK_CACHE_DIR, diskCacheSize);
 }
 public InternalCacheDiskCacheFactory(final Context context, final String diskCacheName,
                                       long diskCacheSize) {
    super(new CacheDirectoryGetter() {
 @Override
 public File getCacheDirectory() {
        File cacheDirectory = context.getCacheDir();
        if (cacheDirectory == null ) {
 return   null ;
 }
        if (diskCacheName != null ) {
 return new File(cacheDirectory, diskCacheName);
 }
 return cacheDirectory;
 }
 }, diskCacheSize);
 }
 }

From the above code, we can see that a 250M cache directory will be created by default, and its path is /data/data/{package}/cache/image_manager_disk_cache/.

Continue to look at the code of its parent class DiskLruCacheFactory:

 public class DiskLruCacheFactory implements DiskCache.Factory {
  private final long diskCacheSize;
  private final CacheDirectoryGetter cacheDirectoryGetter;
 public interface CacheDirectoryGetter {
 File getCacheDirectory();
 }
 ...
 public DiskLruCacheFactory(CacheDirectoryGetter cacheDirectoryGetter, long diskCacheSize) {
    this.diskCacheSize = diskCacheSize;
    this.cacheDirectoryGetter = cacheDirectoryGetter;
 }
 @Override
 public DiskCache build() {
    File cacheDir = cacheDirectoryGetter.getCacheDirectory();
 if (cacheDir == null ) {
 return   null ;
 }
    if (!cacheDir.mkdirs() && (!cacheDir.exists() || !cacheDir.isDirectory())) {
 return   null ;
 }
 return DiskLruCacheWrapper. create (cacheDir, diskCacheSize);
 }
 }

The DiskLruCacheFactory.build() method returns an instance of the DiskLruCacheWrapper class. Let's take a look at the implementation of DiskLruCacheWrapper.

 public class DiskLruCacheWrapper implements DiskCache {
  private static final String TAG = "DiskLruCacheWrapper" ;
  private static final int APP_VERSION = 1;
  private static final int VALUE_COUNT = 1;
  private static DiskLruCacheWrapper wrapper;
  private final SafeKeyGenerator safeKeyGenerator;
  private final File directory;
 private final long maxSize;
  private final DiskCacheWriteLocker writeLocker = new DiskCacheWriteLocker();
  private DiskLruCache diskLruCache;
  @SuppressWarnings( "deprecation" )
 public   static DiskCache create (File directory, long maxSize) {
 return new DiskLruCacheWrapper(directory, maxSize);
 }
 @Deprecated
  @SuppressWarnings({ "WeakerAccess" , "DeprecatedIsStillUsed" })
  protected DiskLruCacheWrapper(File directory, long maxSize) {
    this.directory = directory;
 this.maxSize = maxSize;
    this.safeKeyGenerator = new SafeKeyGenerator();
 }
  private synchronized DiskLruCache getDiskCache() throws IOException {
    if (diskLruCache == null ) {
      diskLruCache = DiskLruCache. open (directory, APP_VERSION, VALUE_COUNT, maxSize);
 }
 return diskLruCache;
 }
 @Override
 public File get( Key   key ) {
    String safeKey = safeKeyGenerator.getSafeKey( key );
 File result = null ;
 try {
      final DiskLruCache.Value value = getDiskCache().get(safeKey);
 if (value != null ) {
        result = value.getFile(0);
 }
 } catch (IOException e) {
 ...
 }
 return result;
 }
 @Override
 public void put( Key   key , Writer writer) {
    String safeKey = safeKeyGenerator.getSafeKey( key );
    writeLocker.acquire(safeKey);
 try {
 try {
        DiskLruCache diskCache = getDiskCache();
        Value current = diskCache.get(safeKey);
 ...
        DiskLruCache.Editor editor = diskCache.edit(safeKey);
 ...
 try {
          File file = editor.getFile(0);
          if (writer.write(file)) {
            editor.commit ();
 }
 finally
          editor.abortUnlessCommitted();
 }
      } catch (IOException e) {
 ...
 }
 finally
      writeLocker.release(safeKey);
 }
 }
 ...
 }

It wraps a DiskLruCache, which mainly provides a SafeKeyGenerator for DiskLruCache to generate a safeKey based on the Key and a write lock DiskCacheWriteLocker.

Back to GlideBuilder.build(Context), diskCacheFactory will be passed into Engine, and will be packaged as a LazyDiskCacheProvider in the Engine's constructor. When needed, the getDiskCache() method will be called, which will call the factory's build() method to return a DiskCache. The code is as follows:

 private static class LazyDiskCacheProvider implements DecodeJob.DiskCacheProvider {
    private final DiskCache.Factory factory;
    private volatile DiskCache diskCache;
    LazyDiskCacheProvider(DiskCache.Factory factory) {
 this.factory = factory;
 }
 ...
 @Override
 public DiskCache getDiskCache() {
      if (diskCache == null ) {
 synchronized (this) {
          if (diskCache == null ) {
            diskCache = factory.build();
 }
          if (diskCache == null ) {
            diskCache = new DiskCacheAdapter();
 }
 }
 }
 return diskCache;
 }
 }

LazyDiskCacheProvider will be passed as an input parameter to the constructor of DecodeJobFactory in the subsequent initialization process of Engine. It will also be passed as an input parameter when DecodeJobFactory creates DecodeJob. DecodeJob will save this LazyDiskCacheProvider as a global variable, and cache will be stored after the resources are loaded and displayed. At the same time, DecodeJob will also set this DiskCacheProvider when DecodeHelper is initialized, so that ResourceCacheGenerator and DataCacheGenerator can read the cache and SourceGenerator can write the cache.

3. ActiveResources

ActiveResources is created in the Engine constructor. A thread with a background priority level (THREAD_PRIORITY_BACKGROUND) is started in the ActiveResources constructor. The cleanReferenceQueue() method is called in this thread to loop and clear the Resources in the ReferenceQueue that are about to be GCed.

 final class ActiveResources {
  private final boolean isActiveResourceRetentionAllowed;
  private final Executor monitorClearedResourcesExecutor;
 @VisibleForTesting
  final Map< Key , ResourceWeakReference> activeEngineResources = new HashMap<>();
  private final ReferenceQueue<EngineResource<?>> resourceReferenceQueue = new ReferenceQueue<>();
  private volatile boolean isShutdown;
  ActiveResources(boolean isActiveResourceRetentionAllowed) {
 this(
        isActiveResourceRetentionAllowed,
        java.util.concurrent.Executors.newSingleThreadExecutor(
            new ThreadFactory() {
 @Override
 public Thread newThread(@NonNull final Runnable r) {
 return new Thread(
                    new Runnable() {
                      @Override
 public void run() {
                        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                        r.run();
 }
 },
 "glide-active-resources" );
 }
 }));
 }
 @VisibleForTesting
 ActiveResources
      boolean isActiveResourceRetentionAllowed, Executor monitorClearedResourcesExecutor) {
    this.isActiveResourceRetentionAllowed = isActiveResourceRetentionAllowed;
    this.monitorClearedResourcesExecutor = monitorClearedResourcesExecutor;
    monitorClearedResourcesExecutor.execute (
 new Runnable() {
 @Override
 public void run() {
            cleanReferenceQueue();
 }
 });
 }
  @SuppressWarnings( "WeakerAccess" )
  @Synthetic void cleanReferenceQueue() {
 while (!isShutdown) {
 try {
        ResourceWeakReference ref = (ResourceWeakReference) resourceReferenceQueue.remove();
        cleanupActiveReference(ref);
 // This section   for testing only .
        DequeuedResourceCallback current = cb;
        if ( current != null ) {
 current .onResourceDequeued();
 }
 // End   for testing only .
      } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
 }
 }
 }
 }

Let's first look at the activate method (save) and deactivate method (delete) of ActiveResources.

 synchronized void activate( Key   key , EngineResource<?> resource) {
    ResourceWeakReference toPut =
        new ResourceWeakReference(
 key , resource, resourceReferenceQueue, isActiveResourceRetentionAllowed);
    ResourceWeakReference removed = activeEngineResources.put( key , toPut);
 if ( removed != null ) {
 removed.reset();
 }
 }
  synchronized void deactivate( Key   key ) {
    ResourceWeakReference removed = activeEngineResources.remove( key );
 if ( removed != null ) {
 removed.reset();
 }
 }

The activate method will encapsulate the parameters into a ResourceWeakReference and then put it into the map. If the corresponding key has a value before, the reset method of the previous value will be called to clear it. The deactivate method first removes it from the map and then calls the reset method of the resource to clear it. ResourceWeakReference inherits WeakReference and only stores some properties of Resource internally.

 static final class ResourceWeakReference extends WeakReference<EngineResource<?>> {
  @SuppressWarnings( "WeakerAccess" ) @Synthetic final Key   key ;
  @SuppressWarnings( "WeakerAccess" ) @Synthetic final boolean isCacheable;
  @Nullable @SuppressWarnings( "WeakerAccess" ) @Synthetic Resource<?> resource;
 @Synthetic
  @SuppressWarnings( "WeakerAccess" )
 ResourceWeakReference
 @NonNull Key   key ,
      @NonNull EngineResource<?> referent,
      @NonNull ReferenceQueue<? super EngineResource<?>> queue,
      boolean isActiveResourceRetentionAllowed) {
 super(referent, queue);
    this.key = Preconditions.checkNotNull( key );
 this.resource =
        referent.isCacheable() && isActiveResourceRetentionAllowed
            ? Preconditions.checkNotNull(referent.getResource()) : null ;
    isCacheable = referent.isCacheable();
 }
 }

The constructor calls super(referent, queue), which puts the object to be GC into ReferenceQueue. The ActiveResources.cleanReferenceQueue() method will always try to get the resource to be GC from the queue, and then call the cleanupActiveReference method to remove the resource from activeEngineResources. The cleanupActiveReference source code is as follows:

 void cleanupActiveReference(@NonNull ResourceWeakReference ref) {
 synchronized (listener) {
 synchronized (this) {
 // Remove active resources
        activeEngineResources.remove(ref. key );
        if (!ref.isCacheable || ref.resource == null ) {
 return ;
 }
 //Construct a new Resource
        EngineResource<?> newResource =
            new EngineResource<>(ref.resource, /*isCacheable=*/ true , /*isRecyclable=*/ false );
        newResource.setResourceListener(ref. key , listener);
 //Callback Engine's onResourceReleased method
 // This will cause this resource to change from active to memory cache state
        listener.onResourceReleased(ref. key , newResource);
 }
 }
 }

Engine implements EngineResource.ResourceListener, where the listener is Engine, and will eventually call back Engine.onResourceReleased.

 @Override
 public synchronized void onResourceReleased( Key cacheKey, EngineResource<?> resource) {
    activeResources.deactivate(cacheKey);
    if (resource.isCacheable()) {
      cache.put(cacheKey, resource);
 } else {
      resourceRecycler.recycle(resource);
 }
 }

If the resource can be cached, it is cached in the memory cache; otherwise, the resource is recycled.

4. Disk cache read

Let's analyze the cache access code. Let's take a look at:

 public synchronized <R> LoadStatus load (...) {
  EngineKey key = keyFactory.buildKey(model, signature, width, height, transformations,
      resourceClass, transcodeClass, options);
  EngineResource<?> active = loadFromActiveResources( key , isMemoryCacheable);
 if (active != null ) {
    cb.onResourceReady(active, DataSource.MEMORY_CACHE);
 return   null ;
 }
  EngineResource<?> cached = loadFromCache( key , isMemoryCacheable);
 if (cached != null ) {
    cb.onResourceReady(cached, DataSource.MEMORY_CACHE);
 return   null ;
 }
  EngineJob<?> current = jobs.get( key , onlyRetrieveFromCache);
 if ( current != null ) {
 current .addCallback(cb, callbackExecutor);
 return new LoadStatus(cb, current );
 }
 EngineJob<R> engineJob =
      engineJobFactory.build(...);
 DecodeJob<R> decodeJob =
      decodeJobFactory.build(...);
 jobs.put( key , engineJob);
  engineJob.addCallback(cb, callbackExecutor);
 engineJob.start(decodeJob);
 return new LoadStatus(cb, engineJob);
 }

The cache needs to be accessed based on the EngineKey. Let's first look at the construction method of EngineKey.

 EngineKey(
 Object model,
 Key signature,
 int width
 int height,
      Map<Class<?>, Transformation<?>> transformations,
 Class<?> resourceClass,
      Class<?> transcodeClass,
 Options options)

model: parameters passed by the load method;

signature: A member variable of BaseRequestOptions. The default value is EmptySignature.obtain()

When loading local resource, it will become ApplicationVersionSignature.obtain(context);

width, height: If override(int size) is not specified, the size of the view will be obtained;

transformations: By default, four corresponding Transformations will be set based on the scaleType of ImageView;

If transform is specified, it is set based on this value;

resourceClass: The decoded resource, if there is no asBitmap or asGif, it will generally be Object;

transcodeClass: The data type to be converted, determined by the as method. When loading local res or network URLs, asDrawable will be called, so it is Drawable

options: If transform has not been set, an option will be specified here by default according to the scaleType of ImageView;

Therefore, when loading the same model multiple times, as long as any of the above parameters changes, it will not be considered the same key;

Back to the Engine.load method, the callback after successful loading from the cache is cb.onResourceReady(cached, DataSource.MEMORY_CACHE); you can see that the resources in the active state and the memory cache state are both DataSource.MEMORY_CACHE, and the loaded resources are all EngineResource objects, which use reference counting to determine whether the resource has been released. If the reference count is 0, the listener.onResourceReleased(key, this) method will be called to notify the outside world that the resource has been released. The listener here is an interface of the ResourceListener type, with only one onResourceReleased(Key key, EngineResource resource) method, Engine implements this interface, and the listener here is Engine. In the Engine.onResourceReleased method, it is determined whether the resource is cacheable. If it is cacheable, the resource is put into the memory cache, otherwise the resource is recycled. The code is as follows:

 public synchronized void onResourceReleased( Key cacheKey, EngineResource<?> resource) {
 // Remove from activeResources
    activeResources.deactivate(cacheKey);
    if (resource.isCacheable()) {
 // Store in MemoryCache
      cache.put(cacheKey, resource);
 } else {
      resourceRecycler.recycle(resource);
 }
 }

Let's go back to the Engine.load method and first look at how to obtain active resources.

 @Nullable
  private EngineResource<?> loadFromActiveResources( Key   key , boolean isMemoryCacheable) {
 // Set skipMemoryCache( true ), then isMemoryCacheable is false , skipping ActiveResources
 if (!isMemoryCacheable) {
 return   null ;
 }
    EngineResource<?> active = activeResources.get( key );
 if (active != null ) {
 // Hit the cache, reference count +1
 active.acquire();
 }
 return active;
 }

Continue to analyze the method of obtaining cached resources. If the cache is not obtained from the active resources, continue to search from the memory cache.

 private EngineResource<?> loadFromCache( Key   key , boolean isMemoryCacheable) {
 // Set skipMemoryCache( true ), then isMemoryCacheable is false , skipping ActiveResources
 if (!isMemoryCacheable) {
 return   null ;
 }
    EngineResource<?> cached = getEngineResourceFromCache( key );
 if (cached != null ) {
 // Hit the cache, reference count +1
 cached.acquire();
 // Move this resource from memoryCache to activeResources
      activeResources.activate( key , cached);
 }
 return cached;
 }

If resources are obtained from memoryCache, they will be moved from memoryCache to activeResources. When loading for the first time, there is no cache in activeResources and memoryCache. DecodeJob and EngineJob will be used to load resources. DecoceJob implements the Runnable interface, and will be submitted to the corresponding thread pool for execution by the EngineJob.start method. In the run method of DecoceJob, cached data will be retrieved from ResourceCacheGenerator and DataCacheGenerator in turn. When neither of them can be obtained, SourceGenerator will be used to load network images or local resources. Resource resources and data resources are both resources in the disk cache.

First look at ResourceCacheGenerator.startNext.

 @Override
 public boolean startNext() {
 // There is only one GlideUrl object in the list
    List< Key > sourceIds = helper.getCacheKeys();
    if (sourceIds.isEmpty()) {
 return   false ;
 }
 // Get three reachable registeredResourceClasses
    // GifDrawable, Bitmap, BitmapDrawable
    List<Class<?>> resourceClasses = helper.getRegisteredResourceClasses();
    if (resourceClasses.isEmpty()) {
      if (File.class.equals(helper.getTranscodeClass())) {
 return   false ;
 }
      throw new IllegalStateException(
 "Failed to find any load path from " + helper.getModelClass() + " to "  
             + helper.getTranscodeClass());
 }
 // Traverse each key in sourceIds , each class in resourceClasses, and some other values ​​to form the key  
 // Try to find the cache file with key in the disk cache
    while (modelLoaders == null || !hasNextModelLoader()) {
 resourceClassIndex++;
      if (resourceClassIndex >= resourceClasses. size ()) {
 sourceIdIndex++;
        if (sourceIdIndex >= sourceIds. size ()) {
 return   false ;
 }
        resourceClassIndex = 0;
 }
 Key sourceId = sourceIds.get(sourceIdIndex);
      Class<?> resourceClass = resourceClasses.get(resourceClassIndex);
      Transformation<?> transformation = helper.getTransformation(resourceClass);
      // PMD.AvoidInstantiatingObjectsInLoops Each iteration is comparatively expensive anyway,
      // we only run until the first one succeeds, the loop runs for   only a limited
      // number of iterations on the order   of 10-20 in the worst case .
 //Construct key  
 currentKey =
          new ResourceCacheKey(// NOPMD AvoidInstantiatingObjectsInLoops
              helper.getArrayPool(),
 sourceId,
              helper.getSignature(),
              helper.getWidth(),
              helper.getHeight(),
 transformation,
 resourceClass,
              helper.getOptions());
 // Find the cache file
      cacheFile = helper.getDiskCache().get(currentKey);
 // If the cache file is found, the loop condition will be false and exit the loop
      if (cacheFile != null ) {
 sourceKey = sourceId;
 // 1. Find the injection code that uses File.class as modelClass during injection
 // 2. Call all injected factory.build methods to get ModelLoader
 // 3. Filter out ModelLoaders that cannot process models
 // The modelLoaders value at this time is:
        // [ByteBufferFileLoader, FileLoader, FileLoader, UnitModelLoader]
        modelLoaders = helper.getModelLoaders(cacheFile);
 modelLoaderIndex = 0;
 }
 }
 // If the cache file is found, the hasNextModelLoader() method will be true and the loop can be executed
 // If no cache file is found, the loop will not be entered and false will be returned directly  
 loadData = null ;
 boolean started = false ;
    while (!started && hasNextModelLoader()) {
      ModelLoader<File, ?> modelLoader = modelLoaders.get(modelLoaderIndex++);
 // In the loop, it will determine whether a ModelLoader can load this file.
      loadData = modelLoader.buildLoadData(cacheFile,
          helper.getWidth(), helper.getHeight(), helper.getOptions());
      if (loadData != null && helper.hasLoadPath(loadData.fetcher.getDataClass())) {
 started = true ;
 // If a ModelLoader is available, then call its fetcher to load data

 // Loading success or failure will notify itself
        loadData.fetcher.loadData(helper.getPriority(), this);
 }
 }
 return started;
 }

The relevant comments of this method are marked. When searching for cache, the key type is ResourceCacheKey. Let's first look at the composition of ResourceCacheKey.

 currentKey =
          new ResourceCacheKey(// NOPMD AvoidInstantiatingObjectsInLoops
              helper.getArrayPool(),
 sourceId,
              helper.getSignature(),
              helper.getWidth(),
              helper.getHeight(),
 transformation,
 resourceClass,
              helper.getOptions());
 ResourceCacheKey(
 ArrayPool arrayPool,
 Key sourceKey,
 Key signature,
 int width,
 int height,
      Transformation<?> appliedTransformation,
      Class<?> decodedResourceClass,
 Options options)

arrayPool: The default value is LruArrayPool, which does not participate in the key's equals method;

sourceKey: If the request is a URL, this is GlideUrl (GlideUrl implements Key);

signature: A member variable of BaseRequestOptions. The default value is EmptySignature.obtain().

When loading local resource, it will become ApplicationVersionSignature.obtain(context);

width, height: If override(int size) is not specified, the size of the view will be obtained;

appliedTransformation: By default, the corresponding BitmapTransformation will be set according to the scaleType of ImageView;

If transform is specified, then it will be the specified value;

decodedResourceClass: the resource type that can be encoded, such as BitmapDrawable, etc.;

options: If transform has not been set, an option will be specified here by default according to the scaleType of ImageView;

In ResourceCacheKey, arrayPool does not participate in the equals method;

After generating ResourceCacheKey, it will search the disk cache according to the key cacheFile = helper.getDiskCache().get(currentKey);

helper.getDiskCache() returns the DiskCache interface, whose implementation class is DiskLruCacheWrapper. See the DiskLruCacheWrapper.get method.

 @Override
 public File get( Key   key ) {
    String safeKey = safeKeyGenerator.getSafeKey( key );
 ...
 File result = null ;
 try {
      final DiskLruCache.Value value = getDiskCache().get(safeKey);
 if (value != null ) {
        result = value.getFile(0);
 }
 } catch (IOException e) {
 ...
 }
 return result;
 }

Here, SafeKeyGenerator is called to generate a SafeKey of type String. In fact, each field in the original key is encrypted using SHA-256, and then the resulting byte array is converted into a hexadecimal string. After the SafeKey is generated, the corresponding cache file is found in DiskCache according to the SafeKey, and then the file is returned.

Back to the ResourceCacheGenerator.startNext method, if the cache is found, loadData.fetcher.loadData(helper.getPriority(), this) will be called; the fetcher here is ByteBufferFetcher, and the loadData method of ByteBufferFetcher will eventually execute callback.onDataReady(result), where callback is ResourceCacheGenerator.

 public void onDataReady(Object data) {
    cb.onDataFetcherReady(sourceKey, data, loadData.fetcher, DataSource.RESOURCE_DISK_CACHE,
 currentKey);
 }

The onDataReady method of ResourceCacheGenerator will call back the onDataFetcherReady method of DecodeJob for subsequent decoding operations.

If ResourceCacheGenerator does not find a cache, it will hand it over to DataCacheGenerator to continue searching for a cache. The general process of this class is the same as ResourceCacheGenerator, but there is a slight difference in that the constructor of DataCacheGenerator has two constructors, one of which is DataCacheGenerator (List , DecodeHelper , FetcherReadyCallback) constructor is prepared for SourceGenerator. Because if there is no disk cache, disk cache operation must be performed after loading from the source. Therefore, SourceGenerator will save the loaded resources to disk, and then hand them over to DataCacheGenerator to retrieve them from disk and give them to ImageView for display.

Look at DataCacheGenerator.startNext:

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

The originalKey here is of DataCacheKey type, and the DataCacheKey construction method is as follows:

DataCacheKey(Key sourceKey, Key signature)

The sourceKey and signature here are consistent with the two variables in ResourceCacheKey. From this, we can see that DataCache caches the original data, and ResourceCache caches the decoded and converted data.

If DataCacheGenerator does not get the cache, it will be handed over to SourceGenerator to load from the source. See SourceGenerator's startNext method.

 @Override
 public boolean startNext() {
 // The first run dataToCache is null  
    if (dataToCache != null ) {
      Object data = dataToCache;
 dataToCache = null ;
 cacheData(data);
 }
 // The first time sourceCacheGenerator is run, it is 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 ;
        loadData.fetcher.loadData(helper.getPriority(), this);
 }
 }
 return started;
 }

After successful loading, the onDataReady method of SourceGenerator will still be called back.

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

First determine whether the acquired data needs to be cached on disk. If disk cache is required, the SourceGenerator.startNext method is called again after being scheduled by DecodeJob and EngineJob. At this time, dataToCache has been assigned a value, and cacheData(data) will be called to write to the disk cache and transfer it to DataCacheGenerator for subsequent processing; otherwise, DecodeJob is notified that the load has been successful.

First look at SourceGenerator.cacheData(data) called in the startNext method of SourceGenerator.

 private void cacheData(Object dataToCache) {
    long startTime = LogTime.getLogTime();
 try {
      Encoder<Object> encoder = helper.getSourceEncoder(dataToCache);
      DataCacheWriter<Object> writer =
          new DataCacheWriter<>(encoder, dataToCache, helper.getOptions());
      originalKey = new DataCacheKey(loadData.sourceKey, helper.getSignature());
      helper.getDiskCache().put(originalKey, writer);
 ...
 finally
      loadData.fetcher.cleanup();
 }
 sourceCacheGenerator =
        new DataCacheGenerator(Collections.singletonList(loadData.sourceKey), helper, this);
 }

The cacheData method first constructs a DataCacheKey to write data to disk, and then creates a new DataCacheGenerator and assigns it to sourceCacheGenerator. Return to startNext to continue execution. At this time, sourceCacheGenerator is not empty, so its startNext() method is called to load the data just written to disk from disk, and returns true to stop DecodeJob from trying to obtain data. At this point, the logic of reading data from the disk cache has been completed, and the next step is to write to the disk cache.

If the disk cache strategy in the onDataReady method of SourceGenerator is not available, the DecodeJob.onDataFetcherReady method will be called back.

 //DecodeJob
 @Override
 public void onDataFetcherReady( Key sourceKey, Object data, DataFetcher<?> fetcher,
      DataSource dataSource, Key attemptedKey) {
    this.currentSourceKey = sourceKey;
 this.currentData = data;
    this.currentFetcher = fetcher;
    this.currentDataSource = dataSource;
    this.currentAttemptingKey = 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 = decodeFromData(currentFetcher, currentData, currentDataSource);
    } catch (GlideException e) {
      e.setLoggingDetails(currentAttemptingKey, currentDataSource);
 throwables.add (e);
 }
 if (resource != null ) {
      notifyEncodeAndRelease(resource, currentDataSource);
 } else {
 runGenerators();
 }
 }

decodeFromRetrievedData(); The subsequent method call chain has been analyzed in the previous article. The main thing it does is: convert the original data into resource data that can be displayed by ImageView and display it on ImageView.

After converting the original data into resource data, DecodeJob.onResourceDecoded(dataSource, decoded) will be called.

 @Synthetic
 @NonNull
  <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;
 // Transform when not resource cache
    if (dataSource != DataSource.RESOURCE_DISK_CACHE) {
      appliedTransformation = decodeHelper.getTransformation(resourceSubClass);
      transformed = appliedTransformation.transform(glideContext, decoded, width, height);
 }
    // TODO: Make this the responsibility of the Transformation.
    if (!decoded.equals(transformed)) {
 decoded.recycle();
 }
    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)) {
 if (encoder == null ) {
        throw new Registry.NoResultEncoderAvailableException(transformed.get().getClass());
 }
 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;
 }

Then there is the disk caching process in this process. The factors that affect encodeStrategy and DiskCacheStrategy.isResourceCacheable. EncodeStrategy is judged based on the type of resource data. If it is Bitmap or BitmapDrawable, it is TRANSFORMED; if it is GifDrawable, it is SOURCE. The disk caching policy defaults to DiskCacheStrategy.AUTOMATIC. The source code is as follows:

 public   static final DiskCacheStrategy AUTOMATIC = new DiskCacheStrategy() {
 public boolean isDataCacheable(DataSource dataSource) {
 return dataSource == DataSource.REMOTE;
 }
 public boolean isResourceCacheable(boolean isFromAlternateCacheKey, DataSource dataSource, EncodeStrategy encodeStrategy) {
 return (isFromAlternateCacheKey && dataSource == DataSource.DATA_DISK_CACHE || dataSource == DataSource. LOCAL ) && encodeStrategy == EncodeStrategy.TRANSFORMED;
 }
 public boolean decodeCachedResource() {
 return   true ;
 }
 public boolean decodeCachedData() {
 return   true ;
 }
 };

Caching is only allowed when the dataSource is DataSource.LOCAL and the encodeStrategy is EncodeStrategy.TRANSFORMED. That is, only resources whose local resource data is Bitmap or BitmapDrawable can be cached.

DeferredEncodeManager.init(key, encoder, lockedResult); in DecodeJob.onResourceDecoded, deferredEncodeManager will be called.

After obtaining the resource data in DecodeFromRetrievedData(); in DecodeJob's decodeFromRetrievedData(), it will call notifyEncodeAndRelease(resource, currentDataSource) using the deferredEncodeManager object for disk cache writing;

 private void notifyEncodeAndRelease(Resource<R> resource, DataSource dataSource) {
 ...
 // Notify callback, resource is ready
    notifyComplete(result, dataSource);
 stage = Stage.ENCODE;
 try {
      if (deferredEncodeManager.hasResourceToEncode()) {
        deferredEncodeManager.encode(diskCacheProvider, options);
 }
 finally
      if (lockedResource != null ) {
        lockedResource.unlock();
 }
 }
 onEncodeComplete();
 }

deferredEncodeManager.encode line writes to disk cache.

 // DecodeJob
 private static class DeferredEncodeManager<Z> {
 private key   key ;
  private ResourceEncoder<Z> encoder;
  private LockedResource<Z> toEncode;
 @Synthetic
 DeferredEncodeManager() { }
  // We just need the encoder and resource type to match, which this will enforce.
  @SuppressWarnings( "unchecked" )
 <X> void init( Key   key , ResourceEncoder<X> encoder, LockedResource<X> toEncode) {
 this. key = key ;
    this.encoder = (ResourceEncoder<Z>) encoder;
    this.toEncode = (LockedResource<Z>) toEncode;
 }
  void encode(DiskCacheProvider diskCacheProvider, Options options) {
    GlideTrace.beginSection( "DecodeJob.encode" );
 try {
 // Save to disk cache
      diskCacheProvider.getDiskCache().put( key ,
          new DataCacheWriter<>(encoder, toEncode, options));
 finally
 toEncode.unlock();
      GlideTrace.endSection();
 }
 }
  boolean hasResourceToEncode() {
 return toEncode != null ;
 }
 void clear() {
 key = null ;
 encoder = null ;
 toEncode = null ;
 }
 }

diskCacheProvider.getDiskCache() gets DiskLruCacheWrapper and calls the put write of DiskLruCacheWrapper. DiskLruCacheWrapper will use the write lock DiskCacheWriteLocker when writing. The lock object is created by the object pool WriteLockPool. The write lock WriteLock implementation is an unfair lock ReentrantLock.

Before the cache is written, it will be determined whether the value corresponding to the key exists, and if it exists, it will not be written. The true write of the cache will be handed over to the ByteBufferEncoder and StreamEncoder two specific classes. The former is responsible for writing the ByteBuffer to the file, and the latter is responsible for writing the InputStream to the file.

So far, the read and write process of disk cache has been analyzed.

5. Memory Cache: Reading of ActiveResource and MemoryCache

Return to the DecodeJob.notifyEncodeAndRelease method, go through the notifyComplete, EngineJob.onResourceReady, notifyCallbacksOfResult method.

On the one hand, the original resource will be wrapped into an EngineResource and then passed to Engine.onEngineJobComplete via a callback.

 @Override
 public synchronized void onEngineJobComplete(
      EngineJob<?> engineJob, Key   key , EngineResource<?> resource) {
 // Set the resource's callback as yourself, so that your callback method will be notified when the resource is released
 if (resource != null ) {
      resource.setResourceListener( key , this);
 // Put the resource into activeResources and the resource becomes active
      if (resource.isCacheable()) {
        activeResources.activate( key , resource);
 }
 }
 // Remove engineJob from Jobs
    jobs.removeIfCurrent( key , engineJob);
 }

Here, the resource will be placed in activeResources and the resource will become active. Later, the SingleRequest.onResourceReady callback will be called using Executors.mainThreadExecutor() to display the resource. Before and after the callback is triggered, there is a place to acquire() and release() operations on the engineResource. These two operations occur in the incrementPendingCallbacks and decrementPendingCallbacks() calls of the notifyCallbacksOfResult() method.

 @Synthetic
 void notifyCallbacksOfResult() {
  ResourceCallbacksAndExecutors copy;
 Key localKey;
  EngineResource<?> localResource;
 synchronized (this) {
 ...
    engineResource = engineResourceFactory.build(resource, isCacheable);
 ...
 hasResource = true ;
 copy = cbs.copy();
    incrementPendingCallbacks(copy. size () + 1);
 localKey = key ;
    localResource = engineResource;
 }
  listener.onEngineJobComplete(this, localKey, localResource);
 for (final ResourceCallbackAndExecutor entry : copy) {
    entry.executor. execute (new CallResourceReady(entry.cb));
 }
  decrementPendingCallbacks();
 }
 synchronized void incrementPendingCallbacks( int   count ) {
 ...
  if (pendingCallbacks.getAndAdd( count ) == 0 && engineResource != null ) {
 engineResource.acquire();
 }
 }
 synchronized void decrementPendingCallbacks() {
 ...
 int decremented = pendingCallbacks.decrementAndGet();
 if (decremented == 0) {
    if (engineResource != null ) {
      engineResource.release();
 }
 release();
 }
 }
 private class CallResourceReady implements Runnable {
  private final ResourceCallback cb;
  CallResourceReady(ResourceCallback cb) {
 this.cb = cb;
 }
 @Override
 public void run() {
    synchronized (EngineJob.this) {
      if (cbs. contains (cb)) {
        // Acquire for this particular callback.
        engineResource.acquire();
        callCallbackOnResourceReady(cb);
 removeCallback(cb);
 }
      decrementPendingCallbacks();
 }
 }
 }

: : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : :

Summarize

When reading the memory cache, it is first read from the memory cache of the LruCache algorithm mechanism, and then read from the memory cache of the weak reference mechanism;

When writing to the memory cache, first write to the memory cache of the weak reference mechanism, and wait until the picture is no longer used, then write to the memory cache of the LruCache algorithm mechanism;

When reading the disk cache, first read the cache of the converted picture, and then read the cache of the original picture.