Glide 缓存机制及源码(二)

清酒暖风

Glide里的缓存

默许状况下，Glide 会正在开端一个新的图片恳求之前查抄以下多级的缓存：

活动资本 (Active Resources) - 如今能否有另外一个 View 正正在展现那张图片？
内乱存缓存 (Memory cache) - 该图片能否近来被减载过并仍存正在于内乱存中？
资本范例（Resource） - 该图片能否之前曾被解码、转换并写进过磁盘缓存？
数据滥觞 (Data) - 构建那个图片的资本能否之前曾被写进过文件缓存？

前两步查抄图片能否正在内乱存中，假如是则间接返回图片。后两步则查抄图片能否正在磁盘上，以便快速但同步天返回图片。
假如四个步调皆已能找到图片，则Glide会返回到本初资本以与回数据（本初文件，Uri, Url等）。
甚么是三级缓存？

内乱存缓存:劣先减载，速率最快
当地缓存:其次减载，速率快
收集缓存:最初减载，速率缓，华侈流量

缓存机造

Glide利用了ActiveResources（活动缓存强援用）+MemoryCache（内乱存缓存Lru算法）+DiskCache(磁盘缓存Lru算法）。

ActiveResources：存储当前界里利用到的图片。界里没有展现后，该Bitmap又被缓存至MemoryCache中，并从ActiveResources中删除。
Memory Cache：存储当前出有利用到的Bitmap，当MemoryCache中获得Bitmap后，该Bitmap又被缓存至ActiveResources中，并从MemoryCache中删除。
Disk Cache：耐久缓存。比方图片减圆角，处置后图片会被缓存到文件中，使用被再次翻开时能够减载缓存间接利用。

        留意： ActiveResources + MemoryCache是内乱存缓存，皆属于运转时缓存，且互斥(统一张图片没有会同时缓存正在ActiveResources+MemoryCache)，使用被杀身后将没有存正在。
        Glide 内乱部是利用 LruCache、强援用战硬盘缓存完成的。
        Glide 次要将缓存分为两块内乱存缓存战硬盘缓存，两种缓存的分离，组成了 Glide 缓存机造的中心。
为什么设想出活动缓存

        由于内乱存缓存利用LRU算法，当您利用Gilde减载并显现第一张图片时，前面又减载了很多图片，同时您的第一张图片借正在用。那个时分内乱存缓存按照LRU算法能够会删除您正正在利用的第一张照片。如许的成果便是您正正在利用的照片找没有到，成果便是程序瓦解。
减载流程

        流程便是那么个流程上面我们经由过程源码减深一下。
Glide源码

减载流程

        1.Engine类
        卖力启动减载并办理活动资本弛缓存资本，它里面有个load办法。出错便是供给途径减载图片的办法。

2.load办法
那个办法里面谦谦的干货。

public <R> LoadStatus load(...) {
long startTime = VERBOSE_IS_LOGGABLE ? LogTime.getLogTime() : 0;
EngineKey key =
keyFactory.buildKey(
model,
signature,
width,
height,
transformations,
resourceClass,
transcodeClass,
options);
EngineResource<?> memoryResource;
synchronized (this) {
memoryResource = loadFromMemory(key, isMemoryCacheable, startTime);
if (memoryResource == null) {
return waitForExistingOrStartNewJob(...);
}
}
// Avoid calling back while holding the engine lock, doing so makes it easier for callers to
// deadlock.
cb.onResourceReady(
memoryResource, DataSource.MEMORY_CACHE, /* isLoadedFromAlternateCacheKey= */ false);
return null;
}

复造代码

        3.EngineKey

        An in memory only cache key used to multiplex loads.
        用于多路传输减载的仅内乱存缓存稀钥.

EngineKey key =
keyFactory.buildKey(
...);

复造代码

4.loadFromMemory
按照上里load办法供给我们去看看loadFromMemory()那个是重面;

5.loadFromActiveResources

6.loadFromCache

7.getEngineResourceFromCache

到那里若有借已找到，那便阐明该图片已保留至内乱存缓存中去。咱担当往下走，逆着源码跑。

8.waitForExistingOrStartNewJob
咱弄个简化版

private <R> LoadStatus waitForExistingOrStartNewJob(...) {
//经由过程增加战删除减载的回调并告诉去办理减载的类
//减载完成时回调。
//咱皆出数据必定出减载完成，那个不论。慢着往下看
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
//使用转换战代码转换。
DecodeJob<R> decodeJob =
decodeJobFactory.build(
...
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);
}

复造代码

9.DecodeJob

class DecodeJob<R>
implements DataFetcherGenerator.FetcherReadyCallback,
Runnable,
Comparable<DecodeJob<?>>,
Poolable {
}
...
//机关办法有个DiskCacheProvider看着跟磁盘缓存有闭咱出来顾顾
DecodeJob(DiskCacheProvider diskCacheProvider, Pools.Pool<DecodeJob<?>> pool) {
this.diskCacheProvider = diskCacheProvider;
this.pool = pool;
}
...

复造代码

LruCache

存正在一个LinkedHashMap寄存数据，而且完成了LRU(起码利用算法)缓存战略。

public class DiskLruCacheFactory implements DiskCache.Factory {
private final long diskCacheSize;
private final CacheDirectoryGetter cacheDirectoryGetter;
/** 正在UI线程中挪用接心以获得缓存文件夹。 */
public interface CacheDirectoryGetter {
File getCacheDirectory();
}
public DiskLruCacheFactory(final String diskCacheFolder, long diskCacheSize) {
this(
new CacheDirectoryGetter() {
@Override
public File getCacheDirectory() {
return new File(diskCacheFolder);
}
},
diskCacheSize);
}
public DiskLruCacheFactory(
final String diskCacheFolder, final String diskCacheName, long diskCacheSize) {
this(
new CacheDirectoryGetter() {
@Override
public File getCacheDirectory() {
return new File(diskCacheFolder, diskCacheName);
}
},
diskCacheSize);
}
/**
*利用此机关函数时，将挪用{@link CacheDirectoryGetter#getCacheDirectory()}
*UI线程，许可正在没有影响机能的状况下停止I/O会见。
*正在UI线程中挪用@param cacheDirectoryGetter接心以获得缓存文件夹。
*@param diskCacheSize LRU磁盘缓存所需的最年夜字节巨细。
*/
// Public API.
@SuppressWarnings("WeakerAccess")
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.isDirectory() || cacheDir.mkdirs()) {
return DiskLruCacheWrapper.create(cacheDir, diskCacheSize);
}
return null;
}
}

复造代码

此中第两个参数0.75f暗示减载果子，即容量到达75%的时分会把内乱存临时增长一倍。
最初那个参数也相当主要，暗示会见元素的排序方法，true暗示根据会见挨次排序，false暗示按败插进的挨次排序。

LruCache完成道理
利用了LinkedHashMap排序方法的特征：因为利用会见挨次排序，举办了get/put操纵的元素会放正在Map最初里。以是当最初一个元素插进出去时，假如当前的缓存数据巨细超越了最年夜限定，那末会删除Map中放正在前里的元素。
Java的四种援用方法

1.强援用(StrongReference)

利用最遍及的援用。
只需援用链出有断开，强援用便没有会断开。- 当内乱存空间不够，扔出OutOfMemoryError停止程序也没有会收受接管具有强援用的工具。
经由过程将工具设置为null去强化援用,使其被收受接管

/** 用于背磁盘缓存写进数据战从磁盘缓存读与数据的接心 */
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";
/** 返回新的磁盘缓存，假如没法创立磁盘缓存，则返回{@code null}*/
@Nullable
DiskCache build();
}
/** 背磁盘缓存中的稀钥实践写进数据的接心 */
interface Writer {
/**
*将数据写进文件
*假如写进操纵应中断，则返回false。
*@param file写进法式应写进的文件。
*/
boolean write(@NonNull File file);
}
/**
*获得给定键处的值的缓存。
*/
@Nullable
File get(Key key);
/**
*@param key要写进的稀钥。
*@param writer一个接心，该接心将正在给定稀钥输出流的状况下写进数据。
*/
void put(Key key, Writer writer);
/**
* 从缓存中删除键战值。.
*/
@SuppressWarnings("unused")
void delete(Key key);
/** Clear the cache. */
void clear();
}

复造代码

2.硬援用(SoftReference)

工具处正在有效但非必需的形态
只要当内乱存空间不够时, GC会收受接管该援用的工具的内乱存。
能够用去完成下速缓存（感化）--好比网页缓存、图片缓存

/** An LRU in memory cache for {@link com.bumptech.glide.load.engine.Resource}s. */
public class LruResourceCache extends LruCache<Key, Resource<?>> implements MemoryCache {
private ResourceRemovedListener listener;
/**
*LruResourceCache的机关函数。
*@param size内乱存缓存可使用的最年夜字节巨细。
*/
public LruResourceCache(long size) {
super(size);
}
@Override
public void setResourceRemovedListener(@NonNull ResourceRemovedListener listener) {
this.listener = listener;
}
@Override
protected void onItemEvicted(@NonNull Key key, @Nullable Resource<?> item) {
if (listener != null && item != null) {
listener.onResourceRemoved(item);
}
}
@Override
protected int getSize(@Nullable Resource<?> item) {
if (item == null) {
return super.getSize(null);
} else {
return item.getSize();
}
}
@SuppressLint("InlinedApi")
@Override
public void trimMemory(int level) {
if (level >= android.content.ComponentCallbacks2.TRIM_MEMORY_BACKGROUND) {
//正正在输进缓存的背景使用法式列表
//退出我们的全部Bitmap缓存
clearMemory();
} else if (level >= android.content.ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN
|| level == android.content.ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL) {
// The app's UI is no longer visible, or app is in the foreground but system is running
// critically low on memory
// Evict oldest half of our bitmap cache
trimToSize(getMaxSize() / 2);
}
}
}

复造代码

3.强援用(WeakReference)

强援用便是只需JVM渣滓收受接管器发明了它，便会将之收受接管。

非必需的工具,比硬援用更强一-些
GC时会被回
被收受接管的几率也没有年夜,由于GC线程劣先级比较低
合用于援用偶然被利用且没有影响渣滓搜集的工具利用：

Map<T,Y> cache = new LinkedHashMap<>(100,0.75f, true):

复造代码

4.实援用(PhantomReference)

没有会决议工具的性命周期
任什么时候候皆能够被渣滓搜集器收受接管
跟踪工具被渣滓搜集器收受接管的活动,起尖兵感化
必需战援用行列ReferenceQueue连合利用

当渣滓收受接管器筹办收受接管一个工具时，假如发明它另有实援用，便会把那个实援用参加到取之联系关系的援用行列中。
程序能够经由过程判定援用行列中能否曾经参加了实援用，去理解被援用的工具能否将要被渣滓收受接管。假如程序发明某个实援用曾经被参加到援用行列，那末就能够正在所援用的工具的内乱存被收受接管之前采纳须要的动作。

Object object = new Object();
String str = "scc";
//皆是强援用

复造代码

援用行列(ReferenceQueue)

无实践存储构造,存储逻辑依靠于内乱部节面之间的干系去表达
存储联系关系的且被GC的硬援用，强援用和实援用

免责声明：假如进犯了您的权益，请联络站少，我们会实时删除侵权内乱容，感谢协作！

Glide 缓存机制及源码(二)

浏览过的版块