【Android开发】深入理解硬盘缓存类DiskLruCache：源码分析

最新推荐文章于 2024-04-06 00:56:06 发布
置顶 最新推荐文章于 2024-04-06 00:56:06 发布
阅读量1.6k 收藏
点赞数
分类专栏： Android开发 文章标签： android开发 DiskLruCache
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BrilliantEagle/article/details/50593434
版权

1.   原理

    DisKLruCache是一个用于硬盘存储的cache的类，它不是Android API，其GitHub地址为【https://github.com/JakeWharton/DiskLruCache】，也有些博客对其进行了介绍【Android DiskLruCache完全解析，硬盘缓存的最佳方案：http://blog.csdn.net/guolin_blog/article/details/28863651】。与LruCache类似，实现依赖于LinkedHashMap<String,Entry>  lruEntries。lruEntries保存了键值对key-value，其中key是String类型，value是字节序列，字节序列最大为Integer.MAX_VALUE。

DisKLruCache本质上是将每个value保存到对应的key生成的文件名的文件中，方便本地索引。一旦总文件超过设定的缓存大小，就删除队头文件。

    DisKLruCache本身不是线程安全的，需要额外的线程安全处理。

2.   源码分析

2.1初始化

  先来看一下成员变量。

    private final File directory;  //路径
    private final File journalFile; //日志文件
    private final File journalFileTmp;  //临时日志文件
    private final int appVersion;  //app的版本
    private final long maxSize;  //缓存的最大容量
    private final int valueCount;  //1个key对应多少个缓存文件
    private long size = 0;
    private Writer journalWriter;  //日志文件写入
    private final LinkedHashMap<String, Entry> lruEntries
            = new LinkedHashMap<String, Entry>(0, 0.75f, true);  //缓存队列
    private int redundantOpCount; 

    /**
     * To differentiate between old and current snapshots, each entry is given
     * a sequence number each time an edit is committed. A snapshot is stale if
     * its sequence number is not equal to its entry's sequence number.
     */
   private long nextSequenceNumber = 0

  DisKLruCache采用静态工厂的模式进行初始化。如果日志文件存在，就从文件中读取相关信息，进一步完善DisKLruCache对象；否则就直接初始化DisKLruCache对象，并且重建日志文件。

    private DiskLruCache(File directory, int appVersion, int valueCount, long maxSize) {
        this.directory = directory;
        this.appVersion = appVersion;
        this.journalFile = new File(directory, JOURNAL_FILE);
        this.journalFileTmp = new File(directory, JOURNAL_FILE_TMP);
        this.valueCount = valueCount;
        this.maxSize = maxSize;
    }

    /**
     * Opens the cache in {@code directory}, creating a cache if none exists
     * there.
     *
     * @param directory a writable directory
     * @param appVersion
     * @param valueCount the number of values per cache entry. Must be positive.
     * @param maxSize the maximum number of bytes this cache should use to store
     * @throws java.io.IOException if reading or writing the cache directory fails
     */
    public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize)
            throws IOException {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }
        if (valueCount <= 0) {
            throw new IllegalArgumentException("valueCount <= 0");
        }

        // prefer to pick up where we left off
        DiskLruCache cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
        if (cache.journalFile.exists()) {//日志文件存在
            try {
                cache.readJournal(); //读取日志文件
                cache.processJournal();// 处理日志文件
                cache.journalWriter = new BufferedWriter(new FileWriter(cache.journalFile, true),
                        IO_BUFFER_SIZE);
                return cache;
            } catch (IOException journalIsCorrupt) {
//                System.logW("DiskLruCache " + directory + " is corrupt: "
//                        + journalIsCorrupt.getMessage() + ", removing");
                cache.delete();
            }
        }

        // create a new empty cache
        directory.mkdirs();
        cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
        cache.rebuildJournal();  //日志文件不存在，就重建日志文件
        return cache;
}

    第一次使用需要新建日志文件，日志只写入了固定的前5行，稍后会解释该日志文件。

    /**
     * Creates a new journal that omits redundant information. This replaces the
     * current journal if it exists.
     */
    private synchronized void rebuildJournal() throws IOException {
        if (journalWriter != null) {
            journalWriter.close();
        }

        Writer writer = new BufferedWriter(new FileWriter(journalFileTmp), IO_BUFFER_SIZE);
        writer.write(MAGIC);
        writer.write("\n");
        writer.write(VERSION_1);
        writer.write("\n");
        writer.write(Integer.toString(appVersion));
        writer.write("\n");
        writer.write(Integer.toString(valueCount));
        writer.write("\n");
        writer.write("\n");

        for (Entry entry : lruEntries.values()) {
            if (entry.currentEditor != null) {
                writer.write(DIRTY + ' ' + entry.key + '\n');
            } else {
                writer.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
            }
        }

        writer.close();
        journalFileTmp.renameTo(journalFile);
        journalWriter = new BufferedWriter(new FileWriter(journalFile, true), IO_BUFFER_SIZE);
    }

  

2.2 Key-Value入队

  Value被保存到本地文件中，留在内存中充当Value角色的是该文件的文件名。这里将value的文件名以静态内部类的形式封装成Entry。Entry接收key为成员变量，并提供了File getCleanFile(int i)为文件的返回值，而File getDirtyFile(inti)返回了临时文件。

 private final class Entry {
        private final String key;

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

        /** True if this entry has ever been published */
        private boolean readable;

        /** The ongoing edit or null if this entry is not being edited. */
        private Editor currentEditor;

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

        private Entry(String key) {
            this.key = key;
            this.lengths = new long[valueCount];
        }

        public String getLengths() throws IOException {
            StringBuilder result = new StringBuilder();
            for (long size : lengths) {
                result.append(' ').append(size);
            }
            return result.toString();
        }

        /**
         * Set lengths using decimal numbers like "10123".
         */
        private void setLengths(String[] strings) throws IOException {
            if (strings.length != valueCount) {
                throw invalidLengths(strings);
            }

            try {
                for (int i = 0; i < strings.length; i++) {
                    lengths[i] = Long.parseLong(strings[i]);
                }
            } catch (NumberFormatException e) {
                throw invalidLengths(strings);
            }
        }

        private IOException invalidLengths(String[] strings) throws IOException {
            throw new IOException("unexpected journal line: " + Arrays.toString(strings));
        }

        public File getCleanFile(int i) {
            return new File(directory, key + "." + i);
        }

        public File getDirtyFile(int i) {
            return new File(directory, key + "." + i + ".tmp");
        }
}

    然后，另一个静态内部类Editor封装了Entry，提供队Entry的编辑功能，并向外提供了Entry对应文件的输入输出流对象，入队时，调用了Editor的commit()函数。需要说明的一点，Editor中又有另一个静态内部类FaultHidingOutputStream，用来封装输出流，这里返回的临时文件的输出流。

/**
     * Edits the values for an entry.
     */
    public final class Editor {
        private final Entry entry;
        private boolean hasErrors;

        private Editor(Entry entry) {
            this.entry = entry;
        }

        /**
         * Returns an unbuffered input stream to read the last committed value,
         * or null if no value has been committed.
         */
        public InputStream newInputStream(int index) throws IOException {
            synchronized (DiskLruCache.this) {
                if (entry.currentEditor != this) {
                    throw new IllegalStateException();
                }
                if (!entry.readable) {
                    return null;
                }
                return new FileInputStream(entry.getCleanFile(index));
            }
        }

        /**
         * Returns the last committed value as a string, or null if no value
         * has been committed.
         */
        public String getString(int index) throws IOException {
            InputStream in = newInputStream(index);
            return in != null ? inputStreamToString(in) : null;
        }

        /**
         * Returns a new unbuffered output stream to write the value at
         * {@code index}. If the underlying output stream encounters errors
         * when writing to the filesystem, this edit will be aborted when
         * {@link #commit} is called. The returned output stream does not throw
         * IOExceptions.
         */
        public OutputStream newOutputStream(int index) throws IOException {
            synchronized (DiskLruCache.this) {
                if (entry.currentEditor != this) {
                    throw new IllegalStateException();
                }
                return new FaultHidingOutputStream(new FileOutputStream(entry.getDirtyFile(index)));
            }
        }

        /**
         * Sets the value at {@code index} to {@code value}.
         */
        public void set(int index, String value) throws IOException {
            Writer writer = null;
            try {
                writer = new OutputStreamWriter(newOutputStream(index), UTF_8);
                writer.write(value);
            } finally {
                closeQuietly(writer);
            }
        }

        /**
         * Commits this edit so it is visible to readers.  This releases the
         * edit lock so another edit may be started on the same key.
         */
        public void commit() throws IOException {
            if (hasErrors) {
                completeEdit(this, false);
                remove(entry.key); // the previous entry is stale
            } else {
                completeEdit(this, true);
            }
        }

        /**
         * Aborts this edit. This releases the edit lock so another edit may be
         * started on the same key.
         */
        public void abort() throws IOException {
            completeEdit(this, false);
        }

        private class FaultHidingOutputStream extends FilterOutputStream {
            private FaultHidingOutputStream(OutputStream out) {
                super(out);
            }

            @Override public void write(int oneByte) {
                try {
                    out.write(oneByte);
                } catch (IOException e) {
                    hasErrors = true;
                }
            }

            @Override public void write(byte[] buffer, int offset, int length) {
                try {
                    out.write(buffer, offset, length);
                } catch (IOException e) {
                    hasErrors = true;
                }
            }

            @Override public void close() {
                try {
                    out.close();
                } catch (IOException e) {
                    hasErrors = true;
                }
            }

            @Override public void flush() {
                try {
                    out.flush();
                } catch (IOException e) {
                    hasErrors = true;
                }
            }
        }
    }

    入队时，commit()函数，调用了completeEdit(Editoreditor, boolean success)函数。该函数将临时文件更名为正式文件，并调整缓冲区大小。

  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) {
            for (int i = 0; i < valueCount; i++) {
                if (!entry.getDirtyFile(i).exists()) {
                    editor.abort();
                    throw new IllegalStateException("edit didn't create file " + i);
                }
            }
        }

        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);
                    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.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
            if (success) {
                entry.sequenceNumber = nextSequenceNumber++;
            }
        } else {
            lruEntries.remove(entry.key);
            journalWriter.write(REMOVE + ' ' + entry.key + '\n');
        }

        if (size > maxSize || journalRebuildRequired()) {
            executorService.submit(cleanupCallable);
        }
    }
调整缓冲区大小是通过仔细线程池中一个线程来调用trimToSize()函数的。
  private void trimToSize() throws IOException {
        while (size > maxSize) {
//            Map.Entry<String, Entry> toEvict = lruEntries.eldest();
            final Map.Entry<String, Entry> toEvict = lruEntries.entrySet().iterator().next();
            remove(toEvict.getKey());
        }
    }

2.3 日志文件

    Cache目录下有一个文件名称是journal，前5行是固定的，已经标注在代码中： 
     *     libcore.io.DiskLruCache  //固定字符串
     *     1      //缓存的版本号
     *     100    //存储的key-value个数
     *     2     //应用的版本号
     *           //空行
     *     CLEAN 3400330d1dfc7f3f7f4b8d4d803dfcf6 832 21054
     *     DIRTY 335c4c6028171cfddfbaae1a9c313c52 
//有效建立或更新的Key-Value的Key，更新包括删除
     *     CLEAN 335c4c6028171cfddfbaae1a9c313c52 3934 2342
     *     REMOVE 335c4c6028171cfddfbaae1a9c313c52 //最新被删除的Key-Value的Key
     *     DIRTY 1ab96a171faeeee38496d8b330771a7a
     *     CLEAN 1ab96a171faeeee38496d8b330771a7a 1600 234
     *     READ 335c4c6028171cfddfbaae1a9c313c52  //最不常使用的Key-Value的Key
     *     READ 3400330d1dfc7f3f7f4b8d4d803dfcf

    日志前5行的读取是通过下面函数进行的。

  private void readJournal() throws IOException {
        InputStream in = new BufferedInputStream(new FileInputStream(journalFile), IO_BUFFER_SIZE);
        try {
            String magic = readAsciiLine(in);
            String version = readAsciiLine(in);
            String appVersionString = readAsciiLine(in);
            String valueCountString = readAsciiLine(in);
            String blank = readAsciiLine(in);
            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 + "]");
            }

            while (true) {
                try {
                    readJournalLine(readAsciiLine(in));//读取剩余日志
                } catch (EOFException endOfJournal) {
                    break;
                }
            }
        } finally {
            closeQuietly(in);
        }
}

    剩余日志是什么含义和作用呢?回到刚才的completeEdit(Editoreditor, boolean success)函数，查看下面的代码段可以得知，当正确提交时，写入了CLEAN，读取出错时写入的是REMOVE：

  private synchronized void completeEdit(Editor editor, boolean success) throws IOException {
……省略无关代码……
        if (entry.readable | success) {
            entry.readable = true;
            journalWriter.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
            if (success) {
                entry.sequenceNumber = nextSequenceNumber++;
            }
        } else {
            lruEntries.remove(entry.key);
            journalWriter.write(REMOVE + ' ' + entry.key + '\n');
        }
      ……省略无关代码……
    }

2.4 Key-Value出队

    根据Key返回的是DisKLruCache内部快照类Snapshot的对象，Snapshot可以返回Key对应的Entry的输入流和Editor对象，不存在就返回null。有了输入流，就可以恢复出来Value。

    /**
     * A snapshot of the values for an entry.
     */
    public final class Snapshot implements Closeable {
        private final String key;
        private final long sequenceNumber;
        private final InputStream[] ins;

        private Snapshot(String key, long sequenceNumber, InputStream[] ins) {
            this.key = key;
            this.sequenceNumber = sequenceNumber;
            this.ins = ins;
        }

        /**
         * Returns an editor for this snapshot's entry, or null if either the
         * entry has changed since this snapshot was created or if another edit
         * is in progress.
         */
        public Editor edit() throws IOException {
            return DiskLruCache.this.edit(key, sequenceNumber);
        }

        /**
         * Returns the unbuffered stream with the value for {@code index}.
         */
        public InputStream getInputStream(int index) {
            return ins[index];
        }

        /**
         * Returns the string value for {@code index}.
         */
        public String getString(int index) throws IOException {
            return inputStreamToString(getInputStream(index));
        }

        @Override public void close() {
            for (InputStream in : ins) {
                closeQuietly(in);
            }
        }
    }

3.   使用

   DisKLruCache可用于大文件对象的硬盘缓存，典型应用是BitMap。这里以BitMap为例走一下DisKLruCache的构造和存取过程。抽取的代码位于Android6.0 SDK中的DisplayingBitmaps工程（路径为：sdk\samples\android-23\ui\）。

  

3.1 DisKLruCache的构造

  构造过程其实就1句话，这里加入了同步锁，以及一些必要条件。

private static final int DISK_CACHE_INDEX = 0；
private final Object mDiskCacheLock = new Object();  //用于同步硬盘缓存的同步锁
private boolean mDiskCacheStarting = true；
private DiskLruCache mDiskLruCache；

  /**
     * Initializes the disk cache.  Note that this includes disk access so this should not be
     * executed on the main/UI thread. By default an ImageCache does not initialize the disk
     * cache when it is created, instead you should call initDiskCache() to initialize it on a
     * background thread.
     */
    public void initDiskCache() {
        // Set up disk cache
        synchronized (mDiskCacheLock) {
            if (mDiskLruCache == null || mDiskLruCache.isClosed()) {
                File diskCacheDir = mCacheParams.diskCacheDir;  //文件路径
                if (mCacheParams.diskCacheEnabled && diskCacheDir != null) {
                    if (!diskCacheDir.exists()) {
                        diskCacheDir.mkdirs();
                    }
//可用空间大于硬盘缓存大小
                    if (getUsableSpace(diskCacheDir) > mCacheParams.diskCacheSize) {
                        try {
                            mDiskLruCache = DiskLruCache.open(
                                    diskCacheDir, 1, 1, mCacheParams.diskCacheSize);//构造
                        } catch (final IOException e) {
                            mCacheParams.diskCacheDir = null;
                            Log.e(TAG, "initDiskCache - " + e);
                        }
                    }
                }
            }
            mDiskCacheStarting = false;
            mDiskCacheLock.notifyAll();
        }
    }

3.2 Key-Value入队

    入队的过程就是通过Key获得快照，通过快照查看是否已经存储过。如果没有存储过，再获得Editor，从Editor获得Key对应文件的输出流，最后将BitMap写入输出流。

/**
     * Adds a bitmap to both memory and disk cache.
     * @param data Unique identifier for the bitmap to store
     * @param value The bitmap drawable to store
     */
    public void addBitmapToCache(String data, BitmapDrawable value) {
        synchronized (mDiskCacheLock) {//同步锁
            // Add to disk cache
            if (mDiskLruCache != null) {
                final String key = hashKeyForDisk(data);
                OutputStream out = null;
                try {
                    DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);//快照
                    if (snapshot == null) {//表明还没有存储该key
                        final DiskLruCache.Editor editor = mDiskLruCache.edit(key);
                        if (editor != null) {
                            out = editor.newOutputStream(DISK_CACHE_INDEX);//输入流
                            value.getBitmap().compress(
                                    mCacheParams.compressFormat, mCacheParams.compressQuality, out);//bitmap写入输入流，即写入到了临时文件
                            editor.commit();//临时文件写入正式文件
                            out.close();
                        }
                    } else {//表明存储过该key
                        snapshot.getInputStream(DISK_CACHE_INDEX).close();
                    }
                } catch (final IOException e) {
                    Log.e(TAG, "addBitmapToCache - " + e);
                } catch (Exception e) {
                    Log.e(TAG, "addBitmapToCache - " + e);
                } finally {
                    try {
                          if (out != null) {
                            out.close();
                        }
                    } catch (IOException e) {}
                }
            }
        }

    }

3.3 Key-Value出队

    出队过程相对简单，就是获得快照，从快照获得输入流，从输入流恢复出Value。

/**
     * Get from disk cache.
     *
     * @param data Unique identifier for which item to get
     * @return The bitmap if found in cache, null otherwise
     */
    public Bitmap getBitmapFromDiskCache(String data) {

        final String key = hashKeyForDisk(data);
        Bitmap bitmap = null;

        synchronized (mDiskCacheLock) {
            while (mDiskCacheStarting) {
                try {
                    mDiskCacheLock.wait();
                } catch (InterruptedException e) {}
            }
            if (mDiskLruCache != null) {
                InputStream inputStream = null;
                try {
                    final DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
                    if (snapshot != null) {
                        if (BuildConfig.DEBUG) {
                            Log.d(TAG, "Disk cache hit");
                        }
                        inputStream = snapshot.getInputStream(DISK_CACHE_INDEX);
                        if (inputStream != null) {
                            FileDescriptor fd = ((FileInputStream) inputStream).getFD();

                            // Decode bitmap, but we don't want to sample so give
                            // MAX_VALUE as the target dimensions
                            bitmap = ImageResizer.decodeSampledBitmapFromDescriptor(
                                    fd, Integer.MAX_VALUE, Integer.MAX_VALUE, this);
                        }
                    }
                } catch (final IOException e) {
                    Log.e(TAG, "getBitmapFromDiskCache - " + e);
                } finally {
                    try {
                        if (inputStream != null) {
                            inputStream.close();
                        }
                    } catch (IOException e) {}
                }
            }
            return bitmap;
        }

4.   总结

    DisKLruCache相对LruCache来讲，有多个内部类，所以较LruCache复杂。就使用来讲，也需要考虑同步操作，更增添了复杂性。








只想瞪你一眼～
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解Linux文件系统及日志分析 超简单易懂
CNFANG的博客
10-26 393
深入理解Linux文件系统及日志分析一、INODE与BLOCK1.1、inode与block概述1.2、inode的内容二、软连接与硬链接2.1、连接文件三、恢复误删除的文件3.1、EXT类型文件恢复1、下面将介绍使用extundelete工具如何恢复误删除的文件。 一、INODE与BLOCK 1.1、inode与block概述 文件是存储在硬盘上的，硬盘最小存储叫做扇区，每个扇区512字节 操作系统读取硬盘信息，不会一个一个扇区读取。实际情况一下连续读取 多个扇区，一次性读取多个扇区，叫做块(Block)
Android中的缓存策略--DiskLruCache
u014732103的博客
11-21 471
LruCache是一种内存缓存策略，但是当存在大量图片的时候，我们指定的缓存内存空间可能很快就会用完，这个时候，LruCache就会频繁的进行trimToSize()操作，不断的将最近最少使用的数据移除，当再次需要该数据时，又得从网络上重新加载。为此，Google提供了一种磁盘缓存的解决方案——DiskLruCache1 DiskLruCache实现原理使用了DiskLruCache缓存策略的APP
DiskLruCache 源码分析
Elson的博客
10-27 723
我们知道 Glide 图片框架的内存缓存用的是 LruCache，磁盘缓存是 DiskLruCache，它们用的都是LRU算法。内存缓存的 LRU 还比较好理解，那么文件是如何按照 LRU 的思想进行管理的呢？本文将以 Glide 框架内的 DiskLruCache 代码来分析它的实现方式。
三分钟学会缓存工具DiskLruCache
weixin_30868855的博客
08-04 233
DiskLruCache是一个十分好用的android缓存工具，我们可以从GitHub上下载其源码：https://github.com/JakeWharton/DiskLruCache DiskLruCache所有的数据都存储在/storage/emulated/0/Android/data/应用包名/cache/XXX文件夹中(你也可以修改，但不建议这样做，原因请继续往下...
DiskLruCache硬盘缓存技术详解
【博客地址迁移到】：https://zhengxiaoyong.com
07-23 3008
上次讲了使用内存缓存LruCache去加载很多图片而不造成OOM，而这种缓存的特点是在应用程序运行时管理内存中的资源（图片）的存储和释放，如果LruCache中有一张图片被释放了，再次加载该图片时需要重新从网络上下载下来，这就显得废流量不说，而且费时，网络不好的状况下用户需要等待，而且在没有网络的情况下不会显示任何数据。 那么怎样才能解决这种情况呢？答案就是加入硬盘缓存DiskLruCache。
Android DiskLruCache 源码解析 硬盘缓存的绝佳方案
sdfwcc的博客
11-15 245
Android DiskLruCache 源码解析 硬盘缓存的绝佳方案
字节Android岗面试必问：Glide的缓存机制，金三银四旗开得胜
m0_61417997的博客
09-08 606
} if (decodeFormat == null) { decodeFormat = DecodeFormat.DEFAULT; } return new Glide(engine, memoryCache, bitmapPool, context, decodeFormat); } } 这里也就是构建Glide对象的地方了。那么观察第22行，你会发现这里new出了一个LruResourceCache，并把它赋值到了memoryCache这个对象上面...
Android DiskLruCache 源码解析 硬盘缓存的绝佳方案，零基础学习android编程
最新发布
2401_84149592的博客
04-06 971
如果已经存在，那么调用。try {if (!||!||!||!||!try {break;} else {首先校验文件头，接下来调用按行读取内容。我们来看看readJournalLine中的操作。return;} else {} else {大家可以回忆下：每个记录至少有一个空格，有的包含两个空格。首先，拿到key，如果是REMOVE的记录呢，会调用;
Android面试题（22）-lruCache与DiskLruCache缓存详解
pgg_cold的博客
03-06 9851
关于lruCache（最近最少使用）的算法，这是一个比较重要的算法，它的应用非常广泛，不仅仅在Android中使用，Linux系统等其他地方中也有使用；今天就来看一看这其中的奥秘；讲到LruCache，就不得不讲一讲LinkedHashMap，而对于LinkedHashMap，它继承的是HashMap，那么我们就先从HashMap开始看起吧；注：此篇博客所讲的所有知识都是在jdk1.8环境下的，j...
android图片二级缓存的实现机制
01-20
本文将深入探讨“Android图片二级缓存的实现机制”，并结合开源项目Android-Universal-Image-Loader（UIL）的源码进行分析。 ### 一、什么是图片二级缓存 二级缓存是Android图片加载库常用的一种优化策略，它通常...
一个案例解析DiskLruCache的基本用法
03-18
一个案例解析DiskLruCache的基本用法 对应博客地址http://blog.csdn.net/leoleohan/article/details/50847209
DiskLruCache.java 完整源码
08-03
Android DiskLruCache的源码
DiskLruCache 的完整源码
11-05
DisLruCache 源码，摘录下来，方便查看。 https://android.googlesource.com/platform/libcore/+/android-4.1.1_r1/luni/src/main/java/libcore/io/DiskLruCache.java https://github.com/JakeWharton/DiskLruCache/blob/master/src/main/java/com/jakewharton/disklrucache/DiskLruCache.java
Android开发——DiskLruCache用法详解以及工作原理深度解析
桉树先生
05-05 495
Android开发——DiskLruCache用法详解以及工作原理深度解析
LruCache 和 DiskLruCache 的使用以及原理分析
三木仔
01-05 8106
常用的三级缓存主要有LruCache、DiskLruCache、网络，其中LruCache对应内存缓存、DiskLruCache对应持久化缓存。Lru表示最近最少使用，意思是当缓存到达限制时候，优先淘汰近期内最少使用的缓存，LruCache和DisLruCache都是如此。
LRUCache的实现原理
春风亲吻我像蛋挞
02-06 2599
简介LRU(Least Recently Used)最近最少使用，最近有时间和空间最近的歧义，所以我更喜欢叫它近期最少使用算法。它的核心思想是，如果一个数据被访问过，我们有理由相信它在将来被访问的概率就越高。于是当LRU缓存达到设定的最大值时将缓存中近期最少使用的对象移除。LRUCache内部使用LinkedHashMap来存储key-value键值对，并将LinkedHashMap设置为访问顺序来
基于com.github.bumptech.glide:disklrucache:4.7.1 的二级缓存
Aa_kai的博客
05-29 1505
添加依赖compile 'com.github.bumptech.glide:disklrucache:4.7.1'同时使用okhttp实现网络请求compile 'com.squareup.okhttp3:okhttp:3.4.1'网络请求添加权限&lt;uses-permission android:name="android.permission.INTERNET"/&gt;网上已经有很多关...
深入理解DiskLruCache源码
01-26 173
作者：岩浆李的游鱼leo2 前言 我们在用第三方框架的时候，比如glide，okhttp等，使用起来已经轻而易举，因为我们只管用。忽视了其用到的缓存技术。让我们一起来理解下缓存的本质。内存缓存一般现在用的是LruCache缓存，磁盘缓存是DiskLruCache。它们用的都是LRU算法（最近最少使用）。网络缓存当然就是网络请求，数据放在后端数据库了。 LRU算法：Least Recently Used 即为近期最少使用。在缓存数据的时候，如果数据不存在缓存中，则放入缓存中，如存在缓存中，会将缓冲重新放入.
LruCache的实现原理(图片三级缓存)
IT_51888_liang的博客
02-28 5186
官方建议使用lrucache进行内存缓存。Lrucache底层实际是维护的一个linkedHashMap集合（他是hashmap的一个子类，可以保证存入和取出顺序的集合，与hashmap不同的是他是一个双向链表从Android2.3以后，系统GC操作更加频繁，所以软引用和弱引用的资源很容易被回收。Android的结构，内部会定义两个属性分别为before和after，用于记录元素的位置；而hasp
《深入理解Spark》：核心技术与源码解析
"深入理解Spark：核心思想与源码分析，作者耿嘉安，机械工业出版社出版，属于大数据技术丛书，详细解析了Spark的核心模块、部署和协作机制，以及SQL处理、流式计算、图计算和机器学习等扩展应用。" Spark作为一款...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值