LRU分析

一种缓存策略。根据最近使用频率，最近最少使用的也认为将来不怎么使用，所以缓存也就越容易清除。
一般LinkedHashMap作为实现，实际上通过构造函数，设置true则每一次操作都会自动将key移动到末尾。

 private final LinkedHashMap<String, Entry> lruEntries =
      new LinkedHashMap<String, Entry>(0, 0.75f, true);

这样一个LRU策略很轻松的就实现了。至于DiskLruCache很明显是缓存到本地文件，事实上内存Map保存的value也只是文件名字，而不是文件内容

数据结构分析

private final class Entry {
    private final String key;

    /** Lengths of this entry's files. */
    private final long[] lengths;

    /** Memoized File objects for this entry to avoid char[] allocations. */
    File[] cleanFiles;//待dirtyFile写入再重命名为此文件，成功即认为写入成功
    File[] dirtyFiles;//一般是tmp文件，先操作此文件

    /** True if this entry has ever been published. */
    private boolean readable;//成功写入即可认为是true

    /** The ongoing edit or null if this entry is not being edited. */
    private Editor currentEditor;//当DIRTY标志则需要赋值一个操作对象

    /** The sequence number of the most recently committed edit to this entry. */
    private long sequenceNumber;

一般写入操作，先认为是dirty类型，操作的也是dirty文件，然后此文件重命名为clean文件则认为操作成功

journal文件

所有这些操作都会记录在journal文件，这个文件类似于日志

• DIRTY 表示初始put操作，例如添加一条缓存，那么此时是DIRTY，不知道结果怎么样
• put时候，成功。那么CLEAN标志
• put时候，失败，REMOVE标志
• get时候，READ标志

既然是磁盘缓存，那么每一次初始化需要加载日志，然后根据日志操作，内存映射相应的填充。
这里一个很重要的概念是DiskLRUCache不存储真实的文件内容，只是存储文件名字。

解析日志文件journal文件

解析需要看看当前文件magic，版本等，然后校验合法再依次解析每一个操作

private void readJournal() throws IOException {
    StrictLineReader reader = new StrictLineReader(new FileInputStream(journalFile), Util.US_ASCII);
    try {
      String magic = reader.readLine();
      String version = reader.readLine();
      String appVersionString = reader.readLine();
      String valueCountString = reader.readLine();
      String blank = reader.readLine();
      if (!MAGIC.equals(magic)
          || !VERSION_1.equals(version)
          || !Integer.toString(appVersion).equals(appVersionString)
          || !Integer.toString(valueCount).equals(valueCountString)
          || !"".equals(blank)) {
        throw new IOException("unexpected journal header: [" + magic + ", " + version + ", "
            + valueCountString + ", " + blank + "]");
      }

解析每一行操作

private void readJournalLine(String line) throws IOException {
    int firstSpace = line.indexOf(' ');
    if (firstSpace == -1) {
      throw new IOException("unexpected journal line: " + line);
    }

    int keyBegin = firstSpace + 1;
    int secondSpace = line.indexOf(' ', keyBegin);
    final String key;
    if (secondSpace == -1) {
      key = line.substring(keyBegin);
      if (firstSpace == REMOVE.length() && line.startsWith(REMOVE)) {
        lruEntries.remove(key);//REMOVE代表写失败，所以内存需要删除此值
        return;
      }
    } else {
      key = line.substring(keyBegin, secondSpace);
    }

    Entry entry = lruEntries.get(key);
    if (entry == null) {
      entry = new Entry(key);
      lruEntries.put(key, entry);
    }

    if (secondSpace != -1 && firstSpace == CLEAN.length() && line.startsWith(CLEAN)) {
      String[] parts = line.substring(secondSpace + 1).split(" ");
      entry.readable = true;
      entry.currentEditor = null;
      entry.setLengths(parts);//CLEAN代表成功写入，设置readable为true
    } else if (secondSpace == -1 && firstSpace == DIRTY.length() && line.startsWith(DIRTY)) {
      entry.currentEditor = new Editor(entry);//至于脏数据需要操作对象
    } else if (secondSpace == -1 && firstSpace == READ.length() && line.startsWith(READ)) {//读操作不需要设置
      // This work was already done by calling lruEntries.get().
    } else {
      throw new IOException("unexpected journal line: " + line);
    }
  }

做一些预处理

private void processJournal() throws IOException {
    deleteIfExists(journalFileTmp);
    for (Iterator<Entry> i = lruEntries.values().iterator(); i.hasNext(); ) {
      Entry entry = i.next();
      if (entry.currentEditor == null) {
        for (int t = 0; t < valueCount; t++) {
          size += entry.lengths[t];
        }
      } else {
        entry.currentEditor = null;//当前是脏数据，所以删除对应的文件
        for (int t = 0; t < valueCount; t++) {
          deleteIfExists(entry.getCleanFile(t));
          deleteIfExists(entry.getDirtyFile(t));
        }
        i.remove();
      }
    }

读取缓存逻辑

public synchronized Value get(String key) throws IOException {
    checkNotClosed();
    Entry entry = lruEntries.get(key);
    if (entry == null) {
      return null;
    }

    if (!entry.readable) {
      return null;//必须设置为可读，数据可以被展示
    }

    for (File file : entry.cleanFiles) {
        // A file must have been deleted manually!
        if (!file.exists()) {
            return null;
        }
    }

    redundantOpCount++;
    journalWriter.append(READ);
    journalWriter.append(' ');
    journalWriter.append(key);
    journalWriter.append('\n');
    if (journalRebuildRequired()) {
      executorService.submit(cleanupCallable);
    }
//返回对应clean文件
    return new Value(key, entry.sequenceNumber, entry.cleanFiles, entry.lengths);
  }

分析一下completeEdit

private synchronized void completeEdit(Editor editor, boolean success) throws IOException {
    Entry entry = editor.entry;
    if (entry.currentEditor != editor) {
      throw new IllegalStateException();
    }

    // If this edit is creating the entry for the first time, every index must have a value.
    if (success && !entry.readable) {//需要成功回写，如果不可展示应该是dirty文件存在
      for (int i = 0; i < valueCount; i++) {
        if (!editor.written[i]) {
          editor.abort();
          throw new IllegalStateException("Newly created entry didn't create value for index " + i);
        }
        if (!entry.getDirtyFile(i).exists()) {
          editor.abort();
          return;
        }
      }
    }

    for (int i = 0; i < valueCount; i++) {
      File dirty = entry.getDirtyFile(i);
      if (success) {
        if (dirty.exists()) {
          File clean = entry.getCleanFile(i);
          dirty.renameTo(clean);//dirty->clean
          long oldLength = entry.lengths[i];
          long newLength = clean.length();
          entry.lengths[i] = newLength;
          size = size - oldLength + newLength;
        }
      } else {
        deleteIfExists(dirty);//删除脏数据
      }
    }

    redundantOpCount++;
    entry.currentEditor = null;
    if (entry.readable | success) {
      entry.readable = true;
      journalWriter.append(CLEAN);
      journalWriter.append(' ');
      journalWriter.append(entry.key);
      journalWriter.append(entry.getLengths());
      journalWriter.append('\n');//成功则CLEAN标志

      if (success) {
        entry.sequenceNumber = nextSequenceNumber++;
      }
    } else {
      lruEntries.remove(entry.key);
      journalWriter.append(REMOVE);
      journalWriter.append(' ');
      journalWriter.append(entry.key);
      journalWriter.append('\n');//失败则REMOVE标志
    }
    journalWriter.flush();

    if (size > maxSize || journalRebuildRequired()) {
      executorService.submit(cleanupCallable);
    }
  }

成功提交与失败回退

 public void commit() throws IOException {
      // The object using this Editor must catch and handle any errors
      // during the write. If there is an error and they call commit
      // anyway, we will assume whatever they managed to write was valid.
      // Normally they should call abort.
      completeEdit(this, true);
      committed = true;
    }

public void abort() throws IOException {
      completeEdit(this, false);
    }

所以成功与失败都是研究completeEdit这个方法。