Glide 缓存总结(一)

public class Engine implements EngineJobListener,
       MemoryCache.ResourceRemovedListener,
       EngineResource.ResourceListener {
   
   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) {
       Util.assertMainThread();

       //1.使用 LRU 机制从内存获取,成功则返回,获取不到,下一步
       EngineResource<?> cached = loadFromCache(key, isMemoryCacheable);
     
       //2.使用弱引用机制从内存获取,成功则返回,获取不到,下一步
       EngineResource<?> active = loadFromActiveResources(key, isMemoryCacheable);

       //创建一个 runnable 下一步提交给线程池使用,run()方法就是线程池要执行的东东
       EngineRunnable runnable = new EngineRunnable(engineJob, decodeJob, priority);
       engineJob.start(runnable);

       if (Log.isLoggable(TAG, Log.VERBOSE)) {
           logWithTimeAndKey("Started new load", startTime, key);
      }
       return new LoadStatus(cb, engineJob);
  }    
}
// runnable
class EngineRunnable implements Runnable, Prioritized {
   

   @Override
   public void run() {
       try {
           //执行 decode()方法
           resource = decode();
      } catch (Exception e) {
           //...
      }
       //...
  }
   private Resource<?> decode() throws Exception {
       if (isDecodingFromCache()) {
           //3.从本地缓存获取
           return decodeFromCache();
      } else {
           //4. 从网络请求
           return decodeFromSource();
      }
  }    
}        

class DecodeJob<A, T, Z> {
   
   private Resource<T> decodeSource() throws Exception {
       Resource<T> decoded = null;
       try {
           // 这是网络请求图片
           final A data = fetcher.loadData(priority);
           //【1.1】磁盘缓存 这儿是可选的: 存储图片的原始数据,没有处理过的
           //下一步1.2】
           decoded = decodeFromSourceData(data);
      } finally {
      }
       return decoded;
  }
   
   private void writeTransformedToCache(Resource<T> transformed) {
       SourceWriter<Resource<T>> writer = new SourceWriter<Resource<T>>(loadProvider.getEncoder(), transformed);
       // 【1.2】 磁盘缓存 这是存储转换过的图片数据
       //下一步【2】
       diskCacheProvider.getDiskCache().put(resultKey, writer);
  }    
}
public class Engine implements EngineJobListener,
       MemoryCache.ResourceRemovedListener,
       EngineResource.ResourceListener {
   
   @Override
   public void onEngineJobComplete(Key key, EngineResource<?> resource) {
       if (resource != null) {

           if (resource.isCacheable()) {
               //【2】即写入了弱引用 内存缓存
                //下一步【3】
               activeResources.put(key, new ResourceWeakReference(key, resource, getReferenceQueue()));
          }
      }
  }  
   
   //【3】
   @Override
   public void onResourceReleased(Key cacheKey, EngineResource resource) {
       // 步骤1：将缓存图片从弱引用缓存中移除
       activeResources.remove(cacheKey);
       if (resource.isCacheable()) {
           // 步骤2：将该图片缓存放入Lru缓存
           cache.put(cacheKey, resource);
      }
  }    
}

public class Engine implements EngineJobListener,
       MemoryCache.ResourceRemovedListener,
       EngineResource.ResourceListener {
// 这是map 是一个强引用对象    
private final Map<Key, WeakReference<EngineResource<?>>> activeResources;    
   
   private ReferenceQueue<EngineResource<?>> getReferenceQueue() {
       if (resourceReferenceQueue == null) {
           resourceReferenceQueue = new ReferenceQueue<EngineResource<?>>();
           MessageQueue queue = Looper.myQueue();
           queue.addIdleHandler(new RefQueueIdleHandler(activeResources, resourceReferenceQueue));
      }
       return resourceReferenceQueue;
  }
   //IdleHandler
   private static class RefQueueIdleHandler implements MessageQueue.IdleHandler {
       private final Map<Key, WeakReference<EngineResource<?>>> activeResources;
       private final ReferenceQueue<EngineResource<?>> queue;

       public RefQueueIdleHandler(Map<Key, WeakReference<EngineResource<?>>> activeResources,
               ReferenceQueue<EngineResource<?>> queue) {
           this.activeResources = activeResources;
           this.queue = queue;
      }

       @Override
       public boolean queueIdle() {
           //从队列中取出一个元素，队列为空则返回null
           //不会空说明ReferenceQueue有被GC回收的ResourceWeakReference对象.
           ResourceWeakReference ref = (ResourceWeakReference) queue.poll();
           if (ref != null) {
               //清空 map 中 被GC回收的ResourceWeakReference对象
               activeResources.remove(ref.key);
          }

           return true;
      }
  }
       
}

class EngineJob implements EngineRunnable.EngineRunnableManager {
   
   private final ExecutorService diskCacheService;
   private final ExecutorService sourceService;    
}