LruDiskCache要点--不可不用的磁盘缓存工具类

LruDiskCache是使用Lru算法的磁盘缓存类，它的功能是将LruCache中缓存位置由内存改为磁盘，一般两者结合使用，用于对处理小文件，图片的缓存。

下面记录下阅读过程中几个比较重要的点：

Get

获取缓存数据时，LruDiskCache会使用LinkedHashmap的算法，也就是最常使用的放在尾部，最少使用的首先被遍历到. 

当你需要获取缓存数据时，首先会得到是一个Snapshot对象（如果数据正常的话：写入成功、在有效内等等），Snapshot其实就是持有缓存文件的输入流，无其它逻辑操作。

 private synchronized Snapshot getByDiskKey(String diskKey) throws IOException {
        checkNotClosed();
        Entry entry = lruEntries.get(diskKey);
        if (entry == null) {
            return null;
        }
 
        if (!entry.readable) {//数据是否被写入成功
            return null;
        }
 
        // 判断时间有效性
        if (entry.expiryTimestamp < System.currentTimeMillis()) {
            for (int i = 0; i < valueCount; i++) {
                File file = entry.getCleanFile(i);
                if (file.exists() && !file.delete()) {
                    throw new IOException("failed to delete " + file);
                }
                size -= entry.lengths[i];
                entry.lengths[i] = 0;
            }
            redundantOpCount++;
            journalWriter.append(DELETE + " " + diskKey + '\n');
            lruEntries.remove(diskKey);
            if (journalRebuildRequired()) {
                executorService.submit(cleanupCallable);
            }
            return null;
        }
 
        //同一个key可能对应多个缓存
        FileInputStream[] ins = new FileInputStream[valueCount];
        try {
            for (int i = 0; i < valueCount; i++) {
                ins[i] = new FileInputStream(entry.getCleanFile(i));
            }
        } catch (FileNotFoundException e) {
            // A file must have been deleted manually!
            for (int i = 0; i < valueCount; i++) {
                if (ins[i] != null) {
                    IOUtils.closeQuietly(ins[i]);
                } else {
                    break;
                }
            }
            return null;
        }
 
        redundantOpCount++;
        journalWriter.append(READ + " " + diskKey + '\n');
        if (journalRebuildRequired()) {
            executorService.submit(cleanupCallable);
        }
 
        return new Snapshot(diskKey, entry.sequenceNumber, ins, entry.lengths);
    }

Set

增加缓存数据时，需先调用edit方法，获得Editor对象，或者null（已经是edit状态时），并写入一条update日志，该条日志并不是写入缓存成功的标识。

注：diskKey为原key经过md5加密后的值。

private synchronized Editor editByDiskKey(String diskKey, long expectedSequenceNumber) throws IOException {
        checkNotClosed();
        Entry entry = lruEntries.get(diskKey);
        if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER &&
                (entry == null || entry.sequenceNumber != expectedSequenceNumber)) {
            return null; // Snapshot is stale.
        }
        if (entry == null) {
            entry = new Entry(diskKey);
            lruEntries.put(diskKey, entry);
        } else if (entry.currentEditor != null) {
            return null; // Another edit is in progress.
        }
 
        Editor editor = new Editor(entry);
        entry.currentEditor = editor;
 
        // Flush the journal before creating files to prevent file leaks.
        journalWriter.write(UPDATE + " " + diskKey + '\n');
        journalWriter.flush();
        return editor;
    }

然后通过Editor对象获得文件的操作流FaultHidingOutputStream对象，该对象在操作文件出错的时候会将hasErrors变量赋值为false，该变量对最终插入数据成功与否起关键性的作用。

代码中entry.getDirtyFile(index)，可能有同学有疑问，为什么是Dirty。其实这里只是作为一个临时文件，在数据写入成功后会将改文件重命名后做为正式文件。

readable表示当前Entry的数据是否被写入过了，如果是，则不能再重复写入。

public OutputStream newOutputStream(int index) throws IOException {
            synchronized (LruDiskCache.this) {
                if (entry.currentEditor != this) {
                    throw new IllegalStateException();
                }
                if (!entry.readable) {
                    written[index] = true;
                }
                File dirtyFile = entry.getDirtyFile(index);
                FileOutputStream outputStream;
                try {
                    outputStream = new FileOutputStream(dirtyFile);
                } catch (FileNotFoundException e) {
                    // Attempt to recreate the cache directory.
                    directory.mkdirs();
                    try {
                        outputStream = new FileOutputStream(dirtyFile);
                    } catch (FileNotFoundException e2) {
                        // We are unable to recover. Silently eat the writes.
                        return NULL_OUTPUT_STREAM;
                    }
                }
                return new FaultHidingOutputStream(outputStream);
            }
        }

最终新增加缓存，需调用Editor对象的commit方法； 

在commit时，会进行判断，如果写入成功，刚加一条clean日志（clean才表示数据插入成功了）

1 2	entry.readable =  true ;   journalWriter.write(CLEAN +  " "  + entry.diskKey +  " "  + EXPIRY_PREFIX + entry.expiryTimestamp + entry.getLengths() +  '\n' );

否则做为脏数据处理，删除文件并写入删除日志。

1	journalWriter.write(DELETE +  " "  + entry.diskKey +  '\n' );

Delete

删除缓存时，先判断是不是edit状态，不是才能执行删除操作，并将删除记录写入日志文件。

如果同一key对应多个缓存文件，则全删。

private synchronized boolean removeByDiskKey(String diskKey) throws IOException {
        checkNotClosed();
        Entry entry = lruEntries.get(diskKey);
        if (entry == null || entry.currentEditor != null) {
            return false;
        }
        for (int i = 0; i < valueCount; i++) {
            File file = entry.getCleanFile(i);
            if (file.exists() && !file.delete()) {
                throw new IOException("failed to delete " + file);
            }
            size -= entry.lengths[i];
            entry.lengths[i] = 0;
        }
        redundantOpCount++;
        journalWriter.append(DELETE + " " + diskKey + '\n');
        lruEntries.remove(diskKey);
        if (journalRebuildRequired()) {
            executorService.submit(cleanupCallable);
        }
        return true;
    }

 

其它分析：

    许多操作的结尾处都会添加一个整理数据的任务，保证数据在可控范围：

     

private final Callable<Void> cleanupCallable = new Callable<Void>() {
        public Void call() throws Exception {
            synchronized (LruDiskCache.this) {
                if (journalWriter == null) {
                    return null; // Closed.
                }
                trimToSize();//超过大小时删除不常用数据
                if (journalRebuildRequired()) {//超过2000条日志后需要重建日志
                    rebuildJournal();//根据现在的数据生成新的日志文件，重命名原有的日志文件
                    redundantOpCount = 0;//初始化
                }
            }
            return null;
        }
    };

    

日志文件是有限制长度的，不能随意增长：

private boolean journalRebuildRequired() {
        final int redundantOpCompactThreshold = 2000;
        return redundantOpCount >= redundantOpCompactThreshold //
                && redundantOpCount >= lruEntries.size();
    }

有些操作会遍历valueCount，这个值表示同一个key下的多个缓存，比如一张图片可分为大中小，这时候就以valueCount来做区分.

(上述代码来源于xutils中的LruDiskCache，相对于Android官网内的DiskLruCache,它显然更加完善。)