Glide硬盘缓存逻辑

当Glide从两级缓存(LruCache及activeResources弱引用缓存)中都获取不到图片时,那么此时就会开启线程尝试从硬盘中读缓存。以下代码引用出自DecodeJob.java及EngineRunnable.java。

从硬盘中读取时有缓存读取缓存,没有缓存直接解码原始图片数据。

    private Resource<?> decode() throws Exception {
        if (isDecodingFromCache()) {
            //从硬盘缓存解码图片
            return decodeFromCache();
        } else {
            //直接解码原始图片
            return decodeFromSource();
        }
    }

我们先说从硬盘缓存解码图片。

从硬盘读取缓存分两种方式DiskCacheStrategy.RESULT(转换后的图片缓存)和DiskCacheStrategy.SOURSE(原始图片缓存)。

    private Resource<?> decodeFromCache() throws Exception {
        Resource<?> result = null;
        try {
            //DiskCacheStrategy.RESULT 解码转换后图片
            result = decodeJob.decodeResultFromCache();
        } catch (Exception e) {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "Exception decoding result from cache: " + e);
            }
        }

        if (result == null) {
            //DiskCacheStrategy.SOURSE 解码原始图片
            result = decodeJob.decodeSourceFromCache();
        }
        return result;
    }

DiskCacheStrategy.RESULT 直接从cache中读取缓存的转换后图片。

 public Resource<Z> decodeResultFromCache() throws Exception {
        if (!diskCacheStrategy.cacheResult()) {
            return null;
        }

        long startTime = LogTime.getLogTime();
        Resource<T> transformed = loadFromCache(resultKey);
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            logWithTimeAndKey("Decoded transformed from cache", startTime);
        }
        startTime = LogTime.getLogTime();
        Resource<Z> result = transcode(transformed);
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            logWithTimeAndKey("Transcoded transformed from cache", startTime);
        }
        return result;
    }

 从磁盘缓存中读取转换后的文件。

    private Resource<T> loadFromCache(Key key) throws IOException {
        File cacheFile = diskCacheProvider.getDiskCache().get(key);
        if (cacheFile == null) {
            return null;
        }

        Resource<T> result = null;
        try {
            result = loadProvider.getCacheDecoder().decode(cacheFile, width, height);
        } finally {
            if (result == null) {
                diskCacheProvider.getDiskCache().delete(key);
            }
        }
        return result;
    }

转码,返回文件。

    private Resource<Z> transcode(Resource<T> transformed) {
        if (transformed == null) {
            return null;
        }
        return transcoder.transcode(transformed);
    }

DiskCacheStrategy.SOURSE 直接从cache中读取缓存的原始图片。

    public Resource<Z> decodeSourceFromCache() throws Exception {
        if (!diskCacheStrategy.cacheSource()) {
            return null;
        }

        long startTime = LogTime.getLogTime();
        //从磁盘缓存中读取原始文件。
        Resource<T> decoded = loadFromCache(resultKey.getOriginalKey());
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            logWithTimeAndKey("Decoded source from cache", startTime);
        }
        return transformEncodeAndTranscode(decoded);
    }

转换图片并且将其缓存到磁盘中,并返回解码后的文件。

    private Resource<Z> transformEncodeAndTranscode(Resource<T> decoded) {
        long startTime = LogTime.getLogTime();
        Resource<T> transformed = transform(decoded);
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            logWithTimeAndKey("Transformed resource from source", startTime);
        }

        writeTransformedToCache(transformed);

        startTime = LogTime.getLogTime();
        Resource<Z> result = transcode(transformed);
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            logWithTimeAndKey("Transcoded transformed from source", startTime);
        }
        return result;
    }

将转换后的文件写到磁盘中。

    private void writeTransformedToCache(Resource<T> transformed) {
        if (transformed == null || !diskCacheStrategy.cacheResult()) {
            return;
        }
        long startTime = LogTime.getLogTime();
        SourceWriter<Resource<T>> writer = new SourceWriter<Resource<T>>(loadProvider.getEncoder(), transformed);
        diskCacheProvider.getDiskCache().put(resultKey, writer);
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            logWithTimeAndKey("Wrote transformed from source to cache", startTime);
        }
    }

我们再说直接解码原始图片。

 private Resource<?> decodeFromSource() throws Exception {
        return decodeJob.decodeFromSource();
    }
  public Resource<Z> decodeFromSource() throws Exception {
        //解码原始数据
        Resource<T> decoded = decodeSource();
        return transformEncodeAndTranscode(decoded);
    }

解码原始数据。

    private Resource<T> decodeSource() throws Exception {
        Resource<T> decoded = null;
        try {
            long startTime = LogTime.getLogTime();
            final A data = fetcher.loadData(priority);
            if (Log.isLoggable(TAG, Log.VERBOSE)) {
                logWithTimeAndKey("Fetched data", startTime);
            }
            if (isCancelled) {
                return null;
            }
            decoded = decodeFromSourceData(data);
        } finally {
            fetcher.cleanup();
        }
        return decoded;
    }

解码源数据。

  private Resource<T> decodeFromSourceData(A data) throws IOException {
        final Resource<T> decoded;
        if (diskCacheStrategy.cacheSource()) {
            decoded = cacheAndDecodeSourceData(data);
        } else {
            //若没有开启磁盘缓存原始图片,则直接解码原始数据
            long startTime = LogTime.getLogTime();
            decoded = loadProvider.getSourceDecoder().decode(data, width, height);
            if (Log.isLoggable(TAG, Log.VERBOSE)) {
                logWithTimeAndKey("Decoded from source", startTime);
            }
        }
        return decoded;
    }

缓存并解码源数据。

   private Resource<T> cacheAndDecodeSourceData(A data) throws IOException {
        long startTime = LogTime.getLogTime();
        SourceWriter<A> writer = new SourceWriter<A>(loadProvider.getSourceEncoder(), data);
        //将原始图片写入磁盘缓存中
        diskCacheProvider.getDiskCache().put(resultKey.getOriginalKey(), writer);
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            logWithTimeAndKey("Wrote source to cache", startTime);
        }

        startTime = LogTime.getLogTime();
        //再从磁盘缓存中读取图片
        Resource<T> result = loadFromCache(resultKey.getOriginalKey());
        if (Log.isLoggable(TAG, Log.VERBOSE) && result != null) {
            logWithTimeAndKey("Decoded source from cache", startTime);
        }
        return result;
    }

转换图片并缓存转换后图片,同:从磁盘缓存中读取原始图片。

    private Resource<Z> transformEncodeAndTranscode(Resource<T> decoded) {
        long startTime = LogTime.getLogTime();
        Resource<T> transformed = transform(decoded);
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            logWithTimeAndKey("Transformed resource from source", startTime);
        }

        writeTransformedToCache(transformed);

        startTime = LogTime.getLogTime();
        Resource<Z> result = transcode(transformed);
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            logWithTimeAndKey("Transcoded transformed from source", startTime);
        }
        return result;
    }

 

<think>嗯,用户想了解如何计算Android中Glide库的磁盘缓存大小。首先,我需要回忆一下Glide的文档和相关源码。记得Glide在初始化时会配置磁盘缓存的大小,默认情况下可能有一个预设的值,比如250MB。但用户想知道具体的计算方法,可能需要深入源码看看。 根据引用[2]中的信息,硬盘缓存大小是在Build方法中设置的,类似于内存缓存的分配逻辑。里面提到LruResourceCache是基于LruCache,使用HashMap来缓存图片。但这里说的是内存缓存,而用户问的是磁盘缓存。不过,可能两者的计算方式有相似之处,或者有特定的类来处理磁盘缓存的大小。 接下来,我需要检查Glide的源码或者文档,确认磁盘缓存的默认大小。通常,磁盘缓存会比内存缓存大很多,比如默认250MB。但用户可能需要自定义这个值,所以需要知道如何设置。引用[5]提到了DataCacheGenerator,可能和磁盘缓存有关,但具体怎么计算还需要进一步分析。 Glide的磁盘缓存使用DiskLruCache,这可能基于一个特定的目录和最大容量。计算磁盘缓存大小的方法可能涉及到DiskLruCache的初始化参数。根据引用[2],内存缓存的大小是通过memorySizeCalculator.getMemoryCacheSize()获取的,而磁盘缓存可能有类似的机制,或者是直接设置一个固定值。 可能用户需要知道的是,Glide默认的磁盘缓存大小是250MB,这个值可以在构建Glide时通过setDiskCache()方法来自定义。比如使用InternalCacheDiskCacheFactory或ExternalCacheDiskCacheFactory,并传入自定义的大小。例如: new InternalCacheDiskCacheFactory(context, 500 * 1024 * 1024); // 500MB 但用户问的是计算方法,即这个默认的250MB是如何确定的,或者是否有自动计算的逻辑。可能Glide并没有根据设备情况动态计算磁盘缓存大小,而是采用固定默认值,允许开发者自行调整。 总结一下,磁盘缓存大小的计算方法通常是开发者手动设置的,默认是250MB,可以通过GlideBuilder配置。而内存缓存的大小计算可能涉及到设备的可用内存,但磁盘缓存可能没有这种自动计算,需要明确指定。因此,回答应该包括默认值、如何自定义,以及相关代码示例。</think>关于Android Glide磁盘缓存大小的计算方法,其配置逻辑与内存缓存类似但存在关键差异。根据源码分析,具体计算方式如下: 1. **默认磁盘缓存大小** 默认情况下,Glide会为磁盘缓存分配$250MB$的存储空间。这个值在DiskCache.Factory接口实现类中硬编码定义: ```java public class InternalCacheDiskCacheFactory extends DiskLruCacheFactory { public InternalCacheDiskCacheFactory(Context context) { this(context, DiskCache.Factory.DEFAULT_DISK_CACHE_SIZE); // 250MB } } ``` 2. **自定义计算方法** 开发者可以通过两种方式调整: ```java // 方式一:设置固定值(单位:字节) GlideBuilder builder = new GlideBuilder(); builder.setDiskCache(new InternalCacheDiskCacheFactory(context, 500 * 1024 * 1024)); // 500MB // 方式二:动态计算(示例根据存储空间比例计算) long availableSpace = getAvailableDiskSpace(context); long customSize = (long)(availableSpace * 0.2); // 取可用空间20% builder.setDiskCache(new InternalCacheDiskCacheFactory(context, customSize)); ``` 3. **缓存实现原理** 磁盘缓存使用LRU算法维护,核心类为DiskLruCacheWrapper。当缓存数据超过设定值时,会根据文件最近使用时间进行淘汰[^2][^5]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值