ExoPlayer架构详解与源码分析(12)——Cache

系列文章目录

ExoPlayer架构详解与源码分析(1)——前言
ExoPlayer架构详解与源码分析(2)——Player
ExoPlayer架构详解与源码分析(3)——Timeline
ExoPlayer架构详解与源码分析(4)——整体架构
ExoPlayer架构详解与源码分析(5)——MediaSource
ExoPlayer架构详解与源码分析(6)——MediaPeriod
ExoPlayer架构详解与源码分析(7)——SampleQueue
ExoPlayer架构详解与源码分析(8)——Loader
ExoPlayer架构详解与源码分析(9)——TsExtractor
ExoPlayer架构详解与源码分析(10)——H264Reader
ExoPlayer架构详解与源码分析(11)——DataSource
ExoPlayer架构详解与源码分析(12)——Cache


文章目录

  • 系列文章目录
  • 前言
  • Cache
  • DataSink
    • CacheDataSink
  • CacheEvictor
    • LeastRecentlyUsedCacheEvictor
  • CachedContentIndex
    • LegacyStorage
    • AtomicFile
    • AtomicFileOutputStream
  • SimpleCache
  • 动态分析
  • 总结


前言

上篇介绍完基本的DataSource,现在可以开始CacheDataSourceTeeDataSource了。
先看下整体结构:
在这里插入图片描述

上图这里假设CacheDataSource原始的上游数据是通过OkHttpDataSource从网络获取

看完上图,是不是感觉非常复杂,没关系我们可以拆解出几个独立的结构一步步了解,可以看到底层的Cache可以作为一个独立的结构,在说CacheDataSource和TeeDataSource前,先把Cache这个基础先了解下。

Cache

可以将资源分段的缓存,资源指的是一个完整的媒体文件(如一个MP4,ts文件),每个资源都有唯一的key,一般使用资源的URI作为Key,有时候同一个资源会有不同的URI(如URI加上了失效时间)这种情况就不适合作为资源的 key了。一个资源由多个CacheSpan组成,CacheSpan包含一个数据起始位置和一个长度,代表了资源中的一段数据,CacheSpan并不一定会被Cache,当没有被Cache时叫做HoleSpan,如果被Cached CacheSpan就会对应一个缓存文件。
下面看下具体方法:

  • getUid 返回缓存的非负唯一标识符,如果在确定唯一标识符之前初始化失败,则返回UID_UNSET 。一个缓存目录对应一个UID,SimpleCache会在缓存目录下创建一个UID的文件用于下次读取UID。

  • release 释放缓存。当不再需要缓存时必须调用此方法。调用此方法后不得使用缓存。此方法可能很慢,通常不应在主线程上调用。

  • getCachedSpans 返回给定资源key的所有CacheSpan。

  • getKeys 返回所有有缓存的资源key。

  • getCacheSpace 返回所有缓存所占磁盘空间大小。

  • startReadWrite 通过传入的资源key获取资源,再通过postion和length获取指定的CacheSpan,当调用DataSource open数据源的时候应该同步调用此方法。

    • 如果指定位置存在已经缓存的数据也就是CacheSpan.isCached为 true,则返回的CacheSpan.file有值,表示当前缓存的文件。
    • 如果没有查询到缓存的CacheSpan则返回一个空的HoleSpan,当调用者从上游获取到数据时可以向当前的HoleSpan指定的范围写入数据,写入完成前此段HoleSpan指定的范围将会锁定,此时再通过startReadWrite会阻塞,当写入完成时,应该通过调用commitFile(File, long)会创建一个已缓存的Span提交到缓存中,此时之前阻塞的startReadWrite将会唤醒,可以获取到一个已缓存的CacheSpan,当调用者完成写入后,必须通过调用releaseHoleSpan来释放锁,此时startReadWrite可以正常获取到已缓存的CacheSpan。此方法可能会阻塞,通常不应在主线程上调用。
    • 入参length表示所请求数据的长度,如果未知则为C.LENGTH_UNSET,如果存在与该postion重叠的缓存条目,则忽略该长度,也就是入参position 的查找优先级高于length,startReadWrite通常被用于后台下载器,当下载器要下载的数据段此时正在被缓存,会等待缓存完成。
  • startReadWriteNonBlocking 和startReadWrite类似,不同的是当DataSource被锁定的时候,不会阻塞会直接返回null,startReadWriteNonBlocking主要是播放器使用,因为播放器是不允许阻塞的,在缓存未获取到时会直接跳过缓存。

  • startFile 获取可写入数据的缓存文件。必须先调用startReadWrite(String, long, long)获得的相应HoleSpan时才能调用。不应在主线程上调用。

  • commitFile 将文件提交到缓存中。必须先调用startReadWrite(String, long, long)获得的相应HoleSpan时才能调用。不应在主线程上调用。

  • releaseHoleSpan 释放从startReadWrite(String, long, long)获得的 HoleSpan。

  • removeResource 删除资源的所有CacheSpans ,同时删除底层文件。

  • removeSpan 从缓存中删除缓存的CacheSpan ,从而删除底层文件。不应在主线程上调用。

  • isCached 返回资源中指定范围的数据是否已完全缓存。

  • getCachedLength 返回从资源的position开始,直到最大maxLength的连续缓存数据的长度。如果未缓存position ,则返回-holeLength ,其中holeLength是从position开始,直到最大值maxLength的连续未缓存数据的长度。

  • getCachedBytes 返回资源position (包含)和(position + length) (不包含)之间的缓存字节总数。

  • applyContentMetadataMutations 存储资源相关的Meta信息如资源的总长度 。不应在主线程上调用。

  • getContentMetadata 获取资源的Meta信息。

一个新的缓存添加时,Cache的一般执行顺序是:

  1. startReadWrite获取HoleSpan,同时锁定这段HoleSpan,防止其他线程再次获取这段HoleSpan。
  2. startFile获取CacheSpan对应的文件。
  3. 对2获取的文件进行写入操作。
  4. commitFile提交写入的文件,并创建与HoleSpan一致的已缓存的CacheSpan提交到Span索引,此时其他线程startReadWrite唤醒可以获取到一个CacheSpan供读取。
  5. releaseHoleSpan释放startReadWrite获取HoleSpan,此时其他线程可以再次startReadWrite获取到一个HoleSpan,并再次写入数据。

继续深挖,在讲Cache实现前说下其他几个类

DataSink

这是一个用来向其中写入数据的组件,概念上是和DataSource完全相反,提供了write供外部写入数据
看下主要方法:

  • open 打开一个数据源,以用来写入指定的数据,同样传入一个DataSpec参照DataSource。
  • write 消费掉传入的数据,用法上和DataSource的read类型,不过这里传入的buffer是用来读取的。
  • close 关闭源。即使open调用抛出IOException 时,也必须调用此方法关闭源。

CacheDataSink

CacheDataSink是DataSink主要实现,主要目的是将数据写入文件缓存,通过Cache获取文件打开写入文件,当达到指定分段大小就获取下个文件继续写入,可以设置数据分段的长度和写入缓冲区的大小。

  /** 默认文件的最大大小为5M */public static final long DEFAULT_FRAGMENT_SIZE = 5 * 1024 * 1024;/** 默认的写入流缓冲为20kb */public static final int DEFAULT_BUFFER_SIZE = 20 * 1024;@Overridepublic void open(DataSpec dataSpec) throws CacheDataSinkException {...try {openNextOutputStream(dataSpec);} catch (IOException e) {throw new CacheDataSinkException(e);}}//打开下一个文件private void openNextOutputStream(DataSpec dataSpec) throws IOException {long length =dataSpec.length == C.LENGTH_UNSET? C.LENGTH_UNSET: min(dataSpec.length - dataSpecBytesWritten, dataSpecFragmentSize);file =//通过cache获取文件的路径cache.startFile(castNonNull(dataSpec.key), dataSpec.position + dataSpecBytesWritten, length);FileOutputStream underlyingFileOutputStream = new FileOutputStream(file);if (bufferSize > 0) {if (bufferedOutputStream == null) {bufferedOutputStream =//设置写入流缓冲大小new ReusableBufferedOutputStream(underlyingFileOutputStream, bufferSize);} else {bufferedOutputStream.reset(underlyingFileOutputStream);}outputStream = bufferedOutputStream;} else {outputStream = underlyingFileOutputStream;}outputStreamBytesWritten = 0;}//写入文件@Overridepublic void write(byte[] buffer, int offset, int length) throws CacheDataSinkException {@Nullable DataSpec dataSpec = this.dataSpec;if (dataSpec == null) {return;}try {int bytesWritten = 0;while (bytesWritten < length) {if (outputStreamBytesWritten == dataSpecFragmentSize) {//是否已经达到文件的分段大小closeCurrentOutputStream();//关闭当前openNextOutputStream(dataSpec);//获取下个文件}int bytesToWrite =//继续写入文件数据(int) min(length - bytesWritten, dataSpecFragmentSize - outputStreamBytesWritten);castNonNull(outputStream).write(buffer, offset + bytesWritten, bytesToWrite);bytesWritten += bytesToWrite;outputStreamBytesWritten += bytesToWrite;dataSpecBytesWritten += bytesToWrite;}} catch (IOException e) {throw new CacheDataSinkException(e);}}private void openNextOutputStream(DataSpec dataSpec) throws IOException {long length =dataSpec.length == C.LENGTH_UNSET? C.LENGTH_UNSET: min(dataSpec.length - dataSpecBytesWritten, dataSpecFragmentSize);file =cache.startFile(//这里调用了cache的startFile方法开始向文件中写入数据castNonNull(dataSpec.key), dataSpec.position + dataSpecBytesWritten, length);FileOutputStream underlyingFileOutputStream = new FileOutputStream(file);if (bufferSize > 0) {if (bufferedOutputStream == null) {bufferedOutputStream =new ReusableBufferedOutputStream(underlyingFileOutputStream, bufferSize);} else {bufferedOutputStream.reset(underlyingFileOutputStream);}outputStream = bufferedOutputStream;} else {outputStream = underlyingFileOutputStream;}outputStreamBytesWritten = 0;}private void closeCurrentOutputStream() throws IOException {if (outputStream == null) {return;}boolean success = false;try {outputStream.flush();success = true;} finally {Util.closeQuietly(outputStream);outputStream = null;File fileToCommit = castNonNull(file);file = null;if (success) {//写入完成后,提交缓存,会将当前的分段的CacheSpan添加入索引cache.commitFile(fileToCommit, outputStreamBytesWritten);} else {fileToCommit.delete();}}}

可以看到CacheDataSink主要作用是控制文件分段写入,至于文件是如何获取的则交给Cache实现。

CacheEvictor

主要用来删除缓存的CacheSpan,根据实现的移除策略调用CacheSpan.removeSpan。
这个直接看实现

LeastRecentlyUsedCacheEvictor

当缓存达到设定的最大值有限,会将最近最少使用的CacheSpan删除。

  public LeastRecentlyUsedCacheEvictor(long maxBytes) {this.maxBytes = maxBytes;//将CacheSpan放入到TreeSet管理排序this.leastRecentlyUsed = new TreeSet<>(LeastRecentlyUsedCacheEvictor::compare);}//指定排序规则private static int compare(CacheSpan lhs, CacheSpan rhs) {//比较CacheSpan最后使用时间long lastTouchTimestampDelta = lhs.lastTouchTimestamp - rhs.lastTouchTimestamp;if (lastTouchTimestampDelta == 0) {// Use the standard compareTo method as a tie-break.return lhs.compareTo(rhs);}return lhs.lastTouchTimestamp < rhs.lastTouchTimestamp ? -1 : 1;}@Override//CacheSpan添加后会回调public void onSpanAdded(Cache cache, CacheSpan span) {leastRecentlyUsed.add(span);currentSize += span.length;//更新当前的总大小evictCache(cache, 0);}private void evictCache(Cache cache, long requiredSpace) {//如果超出最大值则开始cache.removeSpan超出的CacheSpanwhile (currentSize + requiredSpace > maxBytes && !leastRecentlyUsed.isEmpty()) {cache.removeSpan(leastRecentlyUsed.first());}}

可以看出CacheEvictor很简单,主要作用就是管理CacheSpan,决定哪个CacheSpan优先被移除。

CachedContentIndex

主要用于保存缓存资源的索引信息,其中包含了多个资源的信息,通过资源key查询CachedContentIndex获取到CachedContent,CachedContent又包含很多的CacheSpan,最后通过position、length查询到指定的CacheSpan。

 public CachedContentIndex(@Nullable DatabaseProvider databaseProvider,@Nullable File legacyStorageDir,@Nullable byte[] legacyStorageSecretKey,boolean legacyStorageEncrypt,boolean preferLegacyStorage) {checkState(databaseProvider != null || legacyStorageDir != null);keyToContent = new HashMap<>();//资源的key和内容对于的mapidToKey = new SparseArray<>();//资源ID和资源key对应的mapremovedIds = new SparseBooleanArray();//管理移除的资源IDnewIds = new SparseBooleanArray();@NullableStorage databaseStorage =//如果databaseProvider有值直接采用数据库存储索引数据databaseProvider != null ? new DatabaseStorage(databaseProvider) : null;@NullableStorage legacyStorage =//如果legacyStorageDir有值则采用文件存储索引数据legacyStorageDir != null? new LegacyStorage(new File(legacyStorageDir, FILE_NAME_ATOMIC),//索引文件名称cached_content_index.exilegacyStorageSecretKey,//用于文件AES加密的keylegacyStorageEncrypt)//是否加密: null;if (databaseStorage == null || (legacyStorage != null && preferLegacyStorage)) {storage = castNonNull(legacyStorage);previousStorage = databaseStorage;} else {storage = databaseStorage;previousStorage = legacyStorage;}}//首先执行初始化@WorkerThreadpublic void initialize(long uid) throws IOException {storage.initialize(uid);if (previousStorage != null) {previousStorage.initialize(uid);}//如果之前有另外一种数据存储方式,先同步2种方式的数据if (!storage.exists() && previousStorage != null && previousStorage.exists()) {// Copy from previous storage into current storage.previousStorage.load(keyToContent, idToKey);storage.storeFully(keyToContent);} else {// Load from the current storage.storage.load(keyToContent, idToKey);//调用storage价值数据}if (previousStorage != null) {//删除上一种方式数据previousStorage.delete();previousStorage = null;}}@WorkerThread//如果缓存文件发生变化,更新索引文件信息public void store() throws IOException {storage.storeIncremental(keyToContent);// Make ids that were removed since the index was last stored eligible for re-use.int removedIdCount = removedIds.size();for (int i = 0; i < removedIdCount; i++) {idToKey.remove(removedIds.keyAt(i));}removedIds.clear();newIds.clear();}//通过资源key获取或添加一个CachedContentpublic CachedContent getOrAdd(String key) {@Nullable CachedContent cachedContent = keyToContent.get(key);return cachedContent == null ? addNew(key) : cachedContent;}private CachedContent addNew(String key) {int id = getNewId(idToKey);//创建一个新的资源id//实例化CachedContent,此时CachedContent中并没有CacheSpanCachedContent cachedContent = new CachedContent(id, key);keyToContent.put(key, cachedContent);//添加mapidToKey.put(id, key);newIds.put(id, true);storage.onUpdate(cachedContent);return cachedContent;}//更新新CachedContent 中的meta信息public void applyContentMetadataMutations(String key, ContentMetadataMutations mutations) {CachedContent cachedContent = getOrAdd(key);if (cachedContent.applyMetadataMutations(mutations)) {storage.onUpdate(cachedContent);}}

CachedContent 中保存了文件的Key 、Id 、CacheSpan、Meta信息,CachedContentIndex会通过storage将这些信息存储到文件或者数据库,CachedContentIndex中定义了2种存储方式DatabaseStorage和LegacyStorage,分别对应数据库存储和文件存储,这里我们以文件存储为例看下实现。

LegacyStorage

	//构造函数,加密部分省略,这里主要是创建了一个可以原子操作的文件public LegacyStorage(File file, @Nullable byte[] secretKey, boolean encrypt) {...atomicFile = new AtomicFile(file);}@Override//然后是load函数读取索引文件的数据public void load(HashMap<String, CachedContent> content, SparseArray<@NullableType String> idToKey) {checkState(!changed);if (!readFile(content, idToKey)) {content.clear();idToKey.clear();atomicFile.delete();}}private boolean readFile(HashMap<String, CachedContent> content, SparseArray<@NullableType String> idToKey) {if (!atomicFile.exists()) {return true;}@Nullable DataInputStream input = null;try {InputStream inputStream = new BufferedInputStream(atomicFile.openRead());input = new DataInputStream(inputStream);int version = input.readInt();//读取版本if (version < 0 || version > VERSION) {return false;}int flags = input.readInt();//读取是否加密的flagif ((flags & FLAG_ENCRYPTED_INDEX) != 0) {.....}int count = input.readInt();//读取CachedContent数量int hashCode = 0;for (int i = 0; i < count; i++) {//读取CachedContent内容CachedContent cachedContent = readCachedContent(version, input);content.put(cachedContent.key, cachedContent);idToKey.put(cachedContent.id, cachedContent.key);hashCode += hashCachedContent(cachedContent, version);}int fileHashCode = input.readInt();//hash校验boolean isEOF = input.read() == -1;if (fileHashCode != hashCode || !isEOF) {return false;}} catch (IOException e) {return false;} finally {if (input != null) {Util.closeQuietly(input);}}return true;}//读取CachedContent内容private CachedContent readCachedContent(int version, DataInputStream input) throws IOException {int id = input.readInt();//读取IDString key = input.readUTF();//读取KEYDefaultContentMetadata metadata;//获取Meta信息if (version < VERSION_METADATA_INTRODUCED) {long length = input.readLong();ContentMetadataMutations mutations = new ContentMetadataMutations();ContentMetadataMutations.setContentLength(mutations, length);metadata = DefaultContentMetadata.EMPTY.copyWithMutationsApplied(mutations);} else {metadata = readContentMetadata(input);}return new CachedContent(id, key, metadata);}//写入文件private void writeFile(HashMap<String, CachedContent> content) throws IOException {@Nullable DataOutputStream output = null;try {OutputStream outputStream = atomicFile.startWrite();if (bufferedOutputStream == null) {bufferedOutputStream = new ReusableBufferedOutputStream(outputStream);} else {bufferedOutputStream.reset(outputStream);}ReusableBufferedOutputStream bufferedOutputStream = this.bufferedOutputStream;output = new DataOutputStream(bufferedOutputStream);output.writeInt(VERSION);//先写入版本int flags = encrypt ? FLAG_ENCRYPTED_INDEX : 0;output.writeInt(flags);//写入加密的flagif (encrypt) {...}output.writeInt(content.size());//写入长度int hashCode = 0;//写入CachedContent数据for (CachedContent cachedContent : content.values()) {writeCachedContent(cachedContent, output);hashCode += hashCachedContent(cachedContent, VERSION);}output.writeInt(hashCode);//写入校验位atomicFile.endWrite(output);output = null;} finally {Util.closeQuietly(output);}}private void writeCachedContent(CachedContent cachedContent, DataOutputStream output)throws IOException {output.writeInt(cachedContent.id);//写入IDoutput.writeUTF(cachedContent.key);//写入KEYwriteContentMetadata(cachedContent.getMetadata(), output);//写入Meta信息}

看下AtomicFile如何保证原子性操作的。

AtomicFile

AtomicFile写入数据时先调用startWrite,获取到Stream然后写入数据,写入完成后调用endWrite结束。

public OutputStream startWrite() throws IOException {// 写入文件前,先将当前已有文件重命名备份if (baseName.exists()) {if (!backupName.exists()) {if (!baseName.renameTo(backupName)) {Log.w(TAG, "Couldn't rename file " + baseName + " to backup file " + backupName);}} else {baseName.delete();}}OutputStream str;try {str = new AtomicFileOutputStream(baseName);} catch (FileNotFoundException e) {File parent = baseName.getParentFile();if (parent == null || !parent.mkdirs()) {throw new IOException("Couldn't create " + baseName, e);}// 文件夹创建好后,再次尝试创建文件try {str = new AtomicFileOutputStream(baseName);} catch (FileNotFoundException e2) {throw new IOException("Couldn't create " + baseName, e2);}}return str;}//结束写入,将备份文件删除public void endWrite(OutputStream str) throws IOException {str.close();// 流正确关闭后,删除备份文件backupName.delete();}//读取文件留public InputStream openRead() throws FileNotFoundException {restoreBackup();return new FileInputStream(baseName);}//如果备份文件存在说明上次文件写入未正确关闭,可能写入一半就终止了,这个时候恢复上次文件写入前的备份数据private void restoreBackup() {if (backupName.exists()) {baseName.delete();backupName.renameTo(baseName);}}

AtomicFileOutputStream

AtomicFileOutputStream就是对fileOutputStream的一个包装,唯一修改了close方法保证文件立即同步到物理磁盘。

    @Overridepublic void close() throws IOException {if (closed) {return;}closed = true;flush();//flush只是保证java内的数据立即同步try {fileOutputStream.getFD().sync();//相当于通知操作系统立即将操作系统文件缓存同步到文件} catch (IOException e) {Log.w(TAG, "Failed to sync file descriptor:", e);}fileOutputStream.close();}

好了到这里,可以接着来看Cache的实现了。

SimpleCache

Cache的实现类,给定缓存目录只允许有一个 SimpleCache 实例。要删除 SimpleCache,请使用delete(File, DatabaseProvider) ,而不是直接删除目录及其内容。因为如果数据索引是保存在数据库中的时候,无法被删除。
先看下delete静态函数的实现:

public static void delete(File cacheDir, @Nullable DatabaseProvider databaseProvider) {if (!cacheDir.exists()) {return;}File[] files = cacheDir.listFiles();if (files == null) {cacheDir.delete();//删除子文件夹return;}if (databaseProvider != null) {// 获取UIDlong uid = loadUid(files);if (uid != UID_UNSET) {try {//删除文件信息CacheFileMetadataIndex.delete(databaseProvider, uid);} catch (DatabaseIOException e) {Log.w(TAG, "Failed to delete file metadata: " + uid);}try {//删除索引文件或者数据库CachedContentIndex.delete(databaseProvider, uid);} catch (DatabaseIOException e) {Log.w(TAG, "Failed to delete file metadata: " + uid);}}}Util.recursiveDelete(cacheDir);//删除文件夹}

SimpleCache首先要调用startReadWrite获取CacheSpan看下SimpleCache相关代码。

SimpleCache(File cacheDir,CacheEvictor evictor,CachedContentIndex contentIndex,@Nullable CacheFileMetadataIndex fileIndex) {if (!lockFolder(cacheDir)) {throw new IllegalStateException("Another SimpleCache instance uses the folder: " + cacheDir);}this.cacheDir = cacheDir;//缓存文件夹this.evictor = evictor;//缓存删除策略this.contentIndex = contentIndex;//索引文件this.fileIndex = fileIndex;//文件信息保存非必须listeners = new HashMap<>();random = new Random();touchCacheSpans = evictor.requiresCacheSpanTouches();uid = UID_UNSET;// Start cache initialization.final ConditionVariable conditionVariable = new ConditionVariable();new Thread("ExoPlayer:SimpleCacheInit") {//启动线程初始化耗时操作@Overridepublic void run() {synchronized (SimpleCache.this) {conditionVariable.open();//通知父线程继续initialize();SimpleCache.this.evictor.onCacheInitialized();}}}.start();conditionVariable.block();//通过conditionVariable 阻塞线程}private void initialize() {if (!cacheDir.exists()) {try {createCacheDirectories(cacheDir);//创建缓存目录} catch (CacheException e) {initializationException = e;return;}}@Nullable File[] files = cacheDir.listFiles();if (files == null) {String message = "Failed to list cache directory files: " + cacheDir;Log.e(TAG, message);initializationException = new CacheException(message);return;}//查找.uid结尾的ID文件获取ID,个缓存目录根目录包含一个ID文件uid = loadUid(files);if (uid == UID_UNSET) {try {//没有则创建uid = createUid(cacheDir);} catch (IOException e) {String message = "Failed to create cache UID: " + cacheDir;Log.e(TAG, message, e);initializationException = new CacheException(message, e);return;}}try {//初始化contentIndex文件索引contentIndex.initialize(uid);if (fileIndex != null) {fileIndex.initialize(uid);//初始化文件信息数据库Map<String, CacheFileMetadata> fileMetadata = fileIndex.getAll();loadDirectory(cacheDir, /* isRoot= */ true, files, fileMetadata);fileIndex.removeAll(fileMetadata.keySet());} else {//遍历缓存文件夹loadDirectory(cacheDir, /* isRoot= */ true, files, /* fileMetadata= */ null);}} catch (IOException e) {String message = "Failed to initialize cache indices: " + cacheDir;Log.e(TAG, message, e);initializationException = new CacheException(message, e);return;}contentIndex.removeEmpty();//去除空的文件try {contentIndex.store();//同步到文件} catch (IOException e) {Log.e(TAG, "Storing index file failed", e);}}//遍历缓存文件夹private void loadDirectory(File directory,boolean isRoot,@Nullable File[] files,@Nullable Map<String, CacheFileMetadata> fileMetadata) {...for (File file : files) {String fileName = file.getName();if (isRoot && fileName.indexOf('.') == -1) {loadDirectory(file, /* isRoot= */ false, file.listFiles(), fileMetadata);} else {if (isRoot&& (CachedContentIndex.isIndexFile(fileName) || fileName.endsWith(UID_FILE_SUFFIX))) {// 跳过.uid文件continue;}long length = C.LENGTH_UNSET;long lastTouchTimestamp = C.TIME_UNSET;@NullableCacheFileMetadata metadata = fileMetadata != null ? fileMetadata.remove(fileName) : null;if (metadata != null) {//查询到文件信息,直接使用,后面无需再解析相关信息length = metadata.length;lastTouchTimestamp = metadata.lastTouchTimestamp;}@NullableSimpleCacheSpan span =//创建Span,file是有值的,这些CacheSpan都是已缓存的SimpleCacheSpan.createCacheEntry(file, length, lastTouchTimestamp, contentIndex);if (span != null) {addSpan(span);} else {file.delete();}}}}//向contentIndex中添加Spanprivate void addSpan(SimpleCacheSpan span) {contentIndex.getOrAdd(span.key).addSpan(span);totalSpace += span.length;notifySpanAdded(span);}//触发监听,以及evictor管理Span,删除不需要的Spanprivate void notifySpanAdded(SimpleCacheSpan span) {@Nullable ArrayList<Listener> keyListeners = listeners.get(span.key);if (keyListeners != null) {for (int i = keyListeners.size() - 1; i >= 0; i--) {keyListeners.get(i).onSpanAdded(this, span);}}evictor.onSpanAdded(this, span);}@Override//阻塞式获取CacheSpanpublic synchronized CacheSpan startReadWrite(String key, long position, long length)throws InterruptedException, CacheException {Assertions.checkState(!released);checkInitialization();while (true) {CacheSpan span = startReadWriteNonBlocking(key, position, length);if (span != null) {return span;} else {// 阻塞线程,一直到唤醒时继续,有2处会唤醒:// 1. 调用完commitFile文件已经写入,此时已经可以读取了// 2. 调用完releaseHoleSpan,写入的锁已经释放,此时可以被写入wait();}}}public synchronized CacheSpan startReadWriteNonBlocking(String key, long position, long length)throws CacheException {Assertions.checkState(!released);checkInitialization();//获取SpanSimpleCacheSpan span = getSpan(key, position, length);//commitFile完成,文件已经写入if (span.isCached) {// 此时可以被读取return touchSpan(key, span);}//获取或者创建资源的索引文件CachedContent cachedContent = contentIndex.getOrAdd(key);//查询当前Span是否被锁定if (cachedContent.lockRange(position, span.length)) {// 没有被锁定,可以被写入数据return span;}// 当前的Span已经锁定return null;}private SimpleCacheSpan getSpan(String key, long position, long length) {@Nullable CachedContent cachedContent = contentIndex.get(key);//当前资源索引文件不存在,直接创建一个Hole Spanif (cachedContent == null) {return SimpleCacheSpan.createHole(key, position, length);}while (true) {//cachedContent存在,通过position和length查找CacheSpanSimpleCacheSpan span = cachedContent.getSpan(position, length);if (span.isCached && span.file.length() != span.length) {// 文件的大小和Span记录的不一致,文件可能被修改,扫描其他被更改的文件然后移除removeStaleSpans();continue;}return span;}}private SimpleCacheSpan touchSpan(String key, SimpleCacheSpan span) {if (!touchCacheSpans) {return span;}String fileName = Assertions.checkNotNull(span.file).getName();long length = span.length;long lastTouchTimestamp = System.currentTimeMillis();boolean updateFile = false;if (fileIndex != null) {try {//将文件信息保存到数据库,下次加载后直接获取fileIndex.set(fileName, length, lastTouchTimestamp);} catch (IOException e) {Log.w(TAG, "Failed to update index with new touch timestamp.");}} else {// Updating the file itself to incorporate the new last touch timestamp is much slower than// updating the file index. Hence we only update the file if we don't have a file index.updateFile = true;}SimpleCacheSpan newSpan =contentIndex.get(key).setLastTouchTimestamp(span, lastTouchTimestamp, updateFile);notifySpanTouched(span, newSpan);//触发监听return newSpan;}public synchronized File startFile(String key, long position, long length) throws CacheException {...CachedContent cachedContent = contentIndex.get(key);//获取资源索引Assertions.checkNotNull(cachedContent);Assertions.checkState(cachedContent.isFullyLocked(position, length));//确保当前Span的起始范围在,startReadWrite锁定的HoleSpan内...evictor.onStartFile(this, key, position, length);// 这里将缓存文件放入到0-9随机命名的文件夹中File cacheSubDir = new File(cacheDir, Integer.toString(random.nextInt(SUBDIRECTORY_COUNT)));if (!cacheSubDir.exists()) {//创建文件夹createCacheDirectories(cacheSubDir);}long lastTouchTimestamp = System.currentTimeMillis();return SimpleCacheSpan.getCacheFile(//获取文件,供后面写入cacheSubDir, cachedContent.id, position, lastTouchTimestamp);}//缓存文件的命名方式为资源ID.起始位置position.时间戳timestamp.版本v3.exo//如1.940.1692414683255.v3.exo,资源ID为1,开始位置为940,时间戳为1692414683255public static File getCacheFile(File cacheDir, int id, long position, long timestamp) {return new File(cacheDir, id + "." + position + "." + timestamp + SUFFIX);}@Overridepublic synchronized void commitFile(File file, long length) throws CacheException {...SimpleCacheSpan span =//通过文件名称反向构建SpanAssertions.checkNotNull(SimpleCacheSpan.createCacheEntry(file, length, contentIndex));CachedContent cachedContent = Assertions.checkNotNull(contentIndex.get(span.key));//获取索引Assertions.checkState(cachedContent.isFullyLocked(span.position, span.length));//确保当前已被锁定//确保数据一致性long contentLength = ContentMetadata.getContentLength(cachedContent.getMetadata());if (contentLength != C.LENGTH_UNSET) {Assertions.checkState((span.position + span.length) <= contentLength);}if (fileIndex != null) {String fileName = file.getName();try {//文件信息记录文件信息表fileIndex.set(fileName, span.length, span.lastTouchTimestamp);} catch (IOException e) {throw new CacheException(e);}}//将当前已缓存的Span添加到索引addSpan(span);try {contentIndex.store();//同步到索引文件} catch (IOException e) {throw new CacheException(e);}//唤醒阻塞在startReadWrite里其他线程,此时startReadWrite可以返回一个可读的已缓存的SpannotifyAll();}public static SimpleCacheSpan createCacheEntry(File file, long length, long lastTouchTimestamp, CachedContentIndex index) {String name = file.getName();if (!name.endsWith(SUFFIX)) {//版本不一致,文件命名不一致,这里进行统一@Nullable File upgradedFile = upgradeFile(file, index);if (upgradedFile == null) {return null;}file = upgradedFile;name = file.getName();}//正则匹配文件名,提取资源ID,起始位置Position,时间戳Matcher matcher = CACHE_FILE_PATTERN_V3.matcher(name);if (!matcher.matches()) {return null;}int id = Integer.parseInt(Assertions.checkNotNull(matcher.group(1)));@Nullable String key = index.getKeyForId(id);if (key == null) {return null;}if (length == C.LENGTH_UNSET) {length = file.length();}if (length == 0) {return null;}long position = Long.parseLong(Assertions.checkNotNull(matcher.group(2)));if (lastTouchTimestamp == C.TIME_UNSET) {lastTouchTimestamp = Long.parseLong(Assertions.checkNotNull(matcher.group(3)));}//通过以上信息构建Spanreturn new SimpleCacheSpan(key, position, length, lastTouchTimestamp, file);}@Override//释放startReadWrite创建的Hole Spanpublic synchronized void releaseHoleSpan(CacheSpan holeSpan) {Assertions.checkState(!released);CachedContent cachedContent = Assertions.checkNotNull(contentIndex.get(holeSpan.key));cachedContent.unlockRange(holeSpan.position);//解锁Hole SpancontentIndex.maybeRemove(cachedContent.key);notifyAll();//唤醒阻塞在startReadWrite里其他线程,此时已解锁startReadWrite可以返回一个可写的Span}

SimpleCache主要作用就是针对多线程场景下,向外提供缓存文件用于外界读取或者写入,通过HoleSpan作为一个占位符锁定资源,保证并发场景下缓存文件有序的读写。

动态分析

现在假设我们的缓存目录是downloads,现在第一次使用这个缓存目录:

  1. 在第一次初始化缓存目录时,会创建.uid文件,用它的问价名记录当前目录的UID。
  2. 接着开始缓存数据SimpleCache.startFile,创建文件如下方9/1.940.1692785096322.v3.exo,其中9为随机生成的目录名称规则为0-9之间随机,第一个点号前的1代表当前文件对应的资源ID为1,940表示从资源的940byte位置开始写入数据,文件的长度为写入数据的长度,1692785096322代表文件创建的时间戳。v3为文件结构版本号,这里固定可以忽略。
  3. 数据写入完成后,调用SimpleCache.commitFile,通过读取文件名的id,位置,时间戳,构建出CacheSpan添加到CachedContentIndex,CachedContentIndex调用store,更新cached_content_index.exi文件,在其中添加一条当前资源的相关信息,如id,key,Metadata。

在这里插入图片描述
最终产生上面的目录结构,可以看到.exo文件有2种不同的资源ID,说明这里缓存了2个资源,cached_content_index.exi文件中记录了这2个资源的索引信息,现在假设我们再次使用这个缓存目录,这个时候需要重新建立内存中的所有对象CachedContentIndex,先看下文件和CachedContentIndex对象的对应关系图:
在这里插入图片描述
上图右侧可以看到CachedContentIndex包含多个CachedContent,而一个CachedContent又包含多个CachedSpan,这些数据都对应到左侧文件系统里的信息,文件系统构建CachedContentIndex具体过程如下:

  1. SimpleCache.loadUid首先读取缓存目录下的.uid文件,获取UID,用于CachedContentIndex的初始化。
  2. CachedContentIndex.initialize初始化时会通过Storage.load,加载目录中的cached_content_index.exi索引文件,首先获取资源总数count,然后依次读取出其中的资源数据,包括资源的id,key,meta信息(主要包含资源的长度exo_len和跳转后的URL exo_redir),最终构建所有的CachedDtaContent,此时CachedContent中的CachedSpans还未添加。
  3. SimpleCache.loadDirectory扫描缓存目录中的.exo文件,使用文件名字的id(查找索引文件找到对应的key),position,timestamp还有文件的长度路径,共同构建出CachedSpan,通过CachedSpan.key找到到CachedContentIndex中指定的CachedContent,向CachedContent添加CachedSpan。
  4. 至此CachedContentIndex就构建完成了,运行过程中如果产生新的缓存文件,则构建出此文件的CachedSpan添加入CachedContent,最终调用CachedContentIndex.store将内存中的CachedContentIndex同步到文件系统。

总结

分析完Cache这块,可以看到Cache这块就是一个单独的文件读写和管理系统,为上层的CacheDataSource提供支持,下一篇我们继续主线,正式讲下CacheDataSource。


版权声明 ©
本文为CSDN作者山雨楼原创文章
转载请注明出处
原创不易,觉得有用的话,收藏转发点赞支持

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/289124.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

免费的CMS平台,免费CMS文章更新系统

随着网站建设的需求日益增加&#xff0c;寻找一款免费的CMS平台以及配套的文章更新系统成为了许多网站所有者的首要任务。本文将探讨免费的CMS平台的特点&#xff0c;以及CMS文章更新系统的作用和如何选择合适的系统。 免费的CMS平台的特点 开源免费&#xff1a;免费的CMS平台…

Ansible-1

Ansible是一款自动化运维、批量管理服务器的工具&#xff0c;批量系统配置、程序部署、运行命令等功能。基于Python开发&#xff0c;基于ssh进行管理&#xff0c;不需要在被管理端安装任何软件。Ansible在管理远程主机的时候&#xff0c;只有是通过各种模块进行操作的。 需要关…

mysql80-DBA数据库学习1-数据库安装

掌握能力 核心技能 核心技能 mysql部署 官网地址www.mysql.com 或者www.oracle.com https://dev.mysql.com/downloads/repo/yum/ Install the RPM you downloaded for your system, for example: yum install mysql80-community-release-{platform}-{version-number}.noarch…

JAVA虚拟机实战篇之GC调优[2](解决GC问题的手段)

文章目录 版权声明解决GC问题的手段优化基础JVM参数-Xmx 和 –Xms-XX:MaxMetaspaceSize 和 –XX:MetaspaceSize-Xss虚拟机栈大小‐XX:SurvivorRatio和‐XX:MaxTenuringThreshold-XX:DisableExplicitGC 案例&#xff1a;垃圾回收器的选择复习&#xff1a;垃圾回收器的组合关系背…

vue 元素拖动,复制,已复制元素可移动,快捷方便,已解决

注意&#xff1a;使用当前组件时&#xff0c;请先了解组件代码逻辑 下方组件根据自己的需求来更改响应的元素id&#xff0c;调整代码实现逻辑&#xff0c;这里不过多解释 import Vue from "vue";/*** 拖拽*/ Vue.directive("Drag", (el) > {const move…

MySQL表内容的增删查改

在前面几章的内容中我们学习了数据库的增删查改&#xff0c;表的增删查改&#xff0c;这一篇我们来学习一下对表中的内容做增删查改。 CRUD : Create(创建), Retrieve(读取)&#xff0c;Update(更新)&#xff0c;Delete&#xff08;删除&#xff09; 1.创建Create 我们先创建…

深入解析MD5哈希算法:原理、应用与安全性

码到三十五 &#xff1a; 个人主页 心中有诗画&#xff0c;指尖舞代码&#xff0c;目光览世界&#xff0c;步履越千山&#xff0c;人间尽值得 ! 本文将深入探讨MD5哈希算法的工作原理、应用场景以及安全性问题。我们将了解MD5如何生成固定长度的哈希值&#xff0c;以及它在数…

BUG未解之谜01-指针引用之谜

在leetcode里面刷题出现的问题&#xff0c;当我在sortedArrayToBST里面给root赋予初始值NULL之后&#xff0c;问题得到解决&#xff01; 理论上root是未初始化的变量&#xff0c;然后我进入insert函数之后&#xff0c;root引用的内容也是未知值&#xff0c;因此无法给原来的二叉…

could not resolve com.android.tools.build:gradle:4.1.1.

一、报错信息 could not resolve com.android.tools.build:gradle:4.1.1.其实是因为你的网络不能从AS工程提供的mavenCentral()、google()和jcenter()等仓库下载相应的依赖。 二、解决方法 在build.gradle(Project)中&#xff0c;在原先的maven仓库前加上阿里云镜像源。这里…

如何遍历整个DOM树

原文链接&#xff1a;[如何遍历整个DOM树(外网原文链接)](https://chrisdeo.github.io/2019/07/20/%E5%A6%82%E4%BD%95%E9%81%8D%E5%8E%86%E6%95%B4%E4%B8%AADOM%E6%A0%91/) 作为前端开发工程师&#xff0c;我们大部分工作内容其实还是围绕着DOM在进行Javascript的编写&#xf…

SQL把统计结果作为条件进行查询

今天在社区看到一个问题如何返回 统计数值&#xff0c;比较简单&#xff0c;分享一下写法&#xff1a; --测试数据 if not object_id(NTempdb..#T) is nulldrop table #T Go Create table #T([name] nvarchar(21),[year] nvarchar(21),[time] nvarchar(22)) Insert #T select …

手写SpringBoot(二)之动态切换Servlet容器

系列文章目录 手写SpringBoot&#xff08;一&#xff09;之简易版SpringBoot 手写SpringBoot&#xff08;二&#xff09;之动态切换Servlet容器 手写SpringBoot&#xff08;二&#xff09;之动态切换Servlet容器 文章目录 系列文章目录手写SpringBoot&#xff08;二&#xff…

KubeSphere简单介绍及安装使用

KubeSphere 概述 官网地址&#xff1a;https://kubesphere.io/zh/ 什么是 kubesphere KubeSphere 是一个开源的多云容器管理平台&#xff0c;旨在简化企业级 k8s 集群的部署、管理和运维。它提供了一个可视化的管理界面&#xff0c;帮助用户更轻松地管理和监控 k8s 集群&…

访问者模式(数据与行为解耦)

目录 前言 UML plantuml 类图 实战代码 SimpleFileVisitor FileVisitor 接口 删除指定文件夹 模板 IVisitor IVisitable Client 前言 一个类由成员变量和方法组成&#xff0c;成员变量即是类的数据结构&#xff0c;方法则是类的行为。 如果一个类的数据结构稳定&am…

超声波清洗机家用的哪家好?眼镜清洗器推荐!一分钟选购洗眼镜机

相信大家都知道&#xff0c;眼镜脏的话可以使用超声波清洗机清洁&#xff01;因为超声波清洗机能够通过振频的原理&#xff0c;对眼镜的污垢进行清洗。有的朋友会问&#xff0c;我手洗不可以吗&#xff1f;手洗当然可以&#xff0c;但是手洗对于镜片的清洗有作用&#xff0c;但…

【C语言】 gets()puts()fgets()fputs()字符串输入输出函数的用法

文章目录 C语言中的字符串输入输出函数&#xff1a;gets、puts、fgets与fputsgets函数puts函数fgets函数fputs函数 C语言中的字符串输入输出函数知识点总结结语 C语言中的字符串输入输出函数&#xff1a;gets、puts、fgets与fputs 在C语言中&#xff0c;处理字符串的输入和输出…

Java关键字之 assert

语法 assert关键字语法有两种用法&#xff1a; 1、assert <boolean表达式> 如果<boolean表达式>为true&#xff0c;则程序继续执行。 如果为false&#xff0c;则程序抛出AssertionError&#xff0c;并终止执行。 2、assert <boolean表达式> : <错误信…

翔云身份证实名认证接口-PHP调用方法

网络平台集成实名认证接口&#xff0c;是顺应当下网络实名制规定&#xff0c;有效规避法律风险。互联网平台若没有实名认证功能&#xff0c;那么便无法保证网民用户身份的真实性&#xff0c;很有可能被虚假用户攻击&#xff0c;特别是在当网络平台产生垃圾信息乃至是违法信息时…

必示科技携手云杉网络发布“智能可观测性联合解决方案”

近日&#xff0c;必示科技与云杉网络携手发布“智能可观测性联合解决方案”&#xff0c;整体方案融合云杉网络DeepFlow产品在可观测性领域、必示科技AIOps产品在运维数据分析领域的深厚技术积淀&#xff0c;完整实现IT系统高质量、高性能、全栈的可观测数据采集、智能监控和智能…

Go —— defer

defer defer 语句用于延迟函数的调用&#xff0c;常用于关闭文件描述符、释放锁等资源释放场景。但 defer 关键字只能作用于函数或函数调用。 defer func(){ // 函数fmt.Print("Hello&#xff0c;World!") }()defer fmt.Print("Hello&#xff0c;World!&…