一、源码分析：
1、with()
2、load()
3、into()
二、缓存机制
1、Glide缓存机制简介
1.1缓存的图片资源
Glide 需要缓存的 图片资源 分为两类：
原始图片（Source） ：即图片源的图片初始大小 & 分辨率。
转换后的图片(Result) ：经过尺寸缩放和大小压缩等处理后的图片。
当使用 Glide加载图片时，Glide默认 根据 View视图对图片进行压缩 & 转换，而不显示原始图（这也是Glide加载速度高于Picasso的原因）。
1.2 缓存机制设计
Glide的缓存功能设计成 二级缓存：内存缓存和磁盘缓存。
缓存读取顺序：内存缓存 –> 磁盘缓存 –> 网络。
内存缓存默认开启Glide中，内存缓存 & 磁盘缓存相互不影响，独立配置。
可缓存原始图片 & 缓存转换过后的图片，用户自行设置
2、Glide 缓存功能介绍
Glide 的缓存功能分为：内存缓存 & 磁盘缓存
2.1、内存缓存
作用：防止应用重复将图片数据读取到内存当中只缓存转换过后的图片。
实现原理：Glide的内存缓存实现是基于：LruCache 算法（Least Recently Used） 和弱引用机制
LruCache算法：将 最近使用的对象 用强引用的方式 存储在LinkedHashMap中 当缓存满时 ，将最近最少使用的对象从内存中移除 。
弱引用：弱引用的对象具备更短生命周期，当JVM进行垃圾回收时，一旦发现弱引用对象，都会进行回收（无论内存充足否）
2.2、磁盘缓存
作用：防止应用 重复从网络或其他地方重复下载和读取数据
实现原理 :使用Glide 自定义的DiskLruCache算法
该算法基于 Lru 算法中的DiskLruCache算法，具体应用在磁盘缓存的需求场景中
该算法被封装到Glide自定义的工具类中（该工具类基于Android 提供的DiskLruCache工具类

三、 Glide 缓存流程 解析
1、生成缓存Key
Glide 实现内存 & 磁盘缓存是根据图片的缓存Key进行唯一标识，即根据图片的缓存Key去缓存区找对应的缓存图片,生成缓存 Key 的代码发生在Engine类的 load()中

  public synchronized <R> LoadStatus load(
      GlideContext glideContext,
      Object model,
      Key signature,
      int width,
      int height,
      Class<?> resourceClass,
      Class<R> transcodeClass,
      Priority priority,
      DiskCacheStrategy diskCacheStrategy,
      Map<Class<?>, Transformation<?>> transformations,
      boolean isTransformationRequired,
      boolean isScaleOnlyOrNoTransform,
      Options options,
      boolean isMemoryCacheable,
      boolean useUnlimitedSourceExecutorPool,
      boolean useAnimationPool,
      boolean onlyRetrieveFromCache,
      ResourceCallback cb,
      Executor callbackExecutor) {
    long startTime = VERBOSE_IS_LOGGABLE ? LogTime.getLogTime() : 0;

    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);
      if (VERBOSE_IS_LOGGABLE) {
        logWithTimeAndKey("Loaded resource from active resources", startTime, key);
      }
      return null;
    }

    EngineResource<?> cached = loadFromCache(key, isMemoryCacheable);
    if (cached != null) {
      cb.onResourceReady(cached, DataSource.MEMORY_CACHE);
      if (VERBOSE_IS_LOGGABLE) {
        logWithTimeAndKey("Loaded resource from cache", startTime, key);
      }
      return null;
    }

    EngineJob<?> current = jobs.get(key, onlyRetrieveFromCache);
    if (current != null) {
      current.addCallback(cb, callbackExecutor);
      if (VERBOSE_IS_LOGGABLE) {
        logWithTimeAndKey("Added to existing load", startTime, key);
      }
      return new LoadStatus(cb, current);
    }

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

    DecodeJob<R> decodeJob =
        decodeJobFactory.build(
            glideContext,
            model,
            key,
            signature,
            width,
            height,
            resourceClass,
            transcodeClass,
            priority,
            diskCacheStrategy,
            transformations,
            isTransformationRequired,
            isScaleOnlyOrNoTransform,
            onlyRetrieveFromCache,
            options,
            engineJob);

    jobs.put(key, engineJob);

    engineJob.addCallback(cb, callbackExecutor);
    engineJob.start(decodeJob);

    if (VERBOSE_IS_LOGGABLE) {
      logWithTimeAndKey("Started new load", startTime, key);
    }
    return new LoadStatus(cb, engineJob);
  }

2、创建缓存对象 LruResourceCache
LruResourceCache对象是在创建 Glide 对象时创建的，就是GlideBuilder类的memoryCache

@NonNull
  Glide build(@NonNull Context context) {
    if (sourceExecutor == null) {
      sourceExecutor = GlideExecutor.newSourceExecutor();
    }

    if (diskCacheExecutor == null) {
      diskCacheExecutor = GlideExecutor.newDiskCacheExecutor();
    }

    if (animationExecutor == null) {
      animationExecutor = GlideExecutor.newAnimationExecutor();
    }

    if (memorySizeCalculator == null) {
      memorySizeCalculator = new MemorySizeCalculator.Builder(context).build();
    }

    if (connectivityMonitorFactory == null) {
      connectivityMonitorFactory = new DefaultConnectivityMonitorFactory();
    }

    if (bitmapPool == null) {
      int size = memorySizeCalculator.getBitmapPoolSize();
      if (size > 0) {
        bitmapPool = new LruBitmapPool(size);
      } else {
        bitmapPool = new BitmapPoolAdapter();
      }
    }

    if (arrayPool == null) {
      arrayPool = new LruArrayPool(memorySizeCalculator.getArrayPoolSizeInBytes());
    }

    if (memoryCache == null) {
      memoryCache = new LruResourceCache(memorySizeCalculator.getMemoryCacheSize());
    }

    if (diskCacheFactory == null) {
      diskCacheFactory = new InternalCacheDiskCacheFactory(context);
    }

    if (engine == null) {
      engine =
          new Engine(
              memoryCache,
              diskCacheFactory,
              diskCacheExecutor,
              sourceExecutor,
              GlideExecutor.newUnlimitedSourceExecutor(),
              animationExecutor,
              isActiveResourceRetentionAllowed);
    }

    if (defaultRequestListeners == null) {
      defaultRequestListeners = Collections.emptyList();
    } else {
      defaultRequestListeners = Collections.unmodifiableList(defaultRequestListeners);
    }

    RequestManagerRetriever requestManagerRetriever =
        new RequestManagerRetriever(requestManagerFactory);

    return new Glide(
        context,
        engine,
        memoryCache,
        bitmapPool,
        arrayPool,
        requestManagerRetriever,
        connectivityMonitorFactory,
        logLevel,
        defaultRequestOptions.lock(),
        defaultTransitionOptions,
        defaultRequestListeners,
        isLoggingRequestOriginsEnabled);
  }

3、从内存缓存中获取缓存图片
没错，还是Engine类,loadFromActiveResources()和loadFromCache()
弱引用机制的内存缓存获取缓存

@Nullable
  private EngineResource<?> loadFromActiveResources(Key key, boolean isMemoryCacheable) {
    if (!isMemoryCacheable) {
      return null;
    }
    EngineResource<?> active = activeResources.get(key);
    if (active != null) {
      active.acquire();
    }

    return active;
  }

LruCache算法机制的内存缓存获取缓存

  private EngineResource<?> loadFromCache(Key key, boolean isMemoryCacheable) {
    if (!isMemoryCacheable) {
      return null;
    }

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

4、开启加载图片线程
若无法从内存缓存里获得缓存的图片，Glide就会开启加载图片的线程
但在该线程开启后，Glide并不会马上去网络 加载图片，而是采取采用Glide的第2级缓存：磁盘缓存去获取缓存图片
5、从磁盘缓存中获取缓存图片
若无法从内存缓存里获得缓存的图片，就会磁盘缓存去获取缓存图片
6、从网络获取图片资源

 private <Y extends Target<TranscodeType>> Y into(
      @NonNull Y target,
      @Nullable RequestListener<TranscodeType> targetListener,
      BaseRequestOptions<?> options,
      Executor callbackExecutor) {
    Preconditions.checkNotNull(target);
    if (!isModelSet) {
      throw new IllegalArgumentException("You must call #load() before calling #into()");
    }

    Request request = buildRequest(target, targetListener, options, callbackExecutor);

    Request previous = target.getRequest();
    if (request.isEquivalentTo(previous)
        && !isSkipMemoryCacheWithCompletePreviousRequest(options, previous)) {
      request.recycle();
      // If the request is completed, beginning again will ensure the result is re-delivered,
      // triggering RequestListeners and Targets. If the request is failed, beginning again will
      // restart the request, giving it another chance to complete. If the request is already
      // running, we can let it continue running without interruption.
      if (!Preconditions.checkNotNull(previous).isRunning()) {
        // Use the previous request rather than the new one to allow for optimizations like skipping
        // setting placeholders, tracking and un-tracking Targets, and obtaining View dimensions
        // that are done in the individual Request.
        previous.begin();
      }
      return target;
    }

    requestManager.clear(target);
    target.setRequest(request);
    requestManager.track(target, request);

    return target;
  }

7、写入磁盘缓存
8、写入内存缓存
9、写入弱应用缓存
10、显示图片
在将图片写入内存缓存和磁盘缓存后，图片最终显示出来
在下次加载时，将通过二级缓存从而提高图片加载效率。