Android缓存机制学习笔记

来源：互联网发布：java i18n 国际化编辑：程序博客网时间：2024/05/16 08:22

一、内存缓存：———>LruCache：

1、原因：Api Level 9 垃圾回收机制更倾向于回收持有软引用和弱引用的对象，让软引用和弱引用变得不可靠。而Bitmap放在内存的堆区域中。

原理：LruCache中的主要原理是将最近使用的对象用强引用存储在LinkedHashMap中，并且将最近最少使用的对象在缓存值达到预定值之前从内存中移除。

数据结构：LinkedHashMap，LinkedHashMap是一个双向循环链表。可以基于访问顺序来保存缓存中的对象。在链表的尾部是最近刚刚使用的结点，在链表的头部是是最近最少使用的结点。

使用LinkedHashMap的原因：需要频繁的插入、删除等操作，可使用LinkedList，还需要基于key-value保存数据，还需要保存插入数据的顺序，则使用LinkedHashMap

2、成员变量、构造方法：

public class LruCache<K, V> {
    private final LinkedHashMap<K, V> map;// 声明一个LinkedHashMap
    private int size;// 已经存储的数量大小
    private int maxSize;// 规定的最大存储空间
    private int putCount;// put的次数
    private int createCount;// create的次数
    private int evictionCount;// 回首的次数
    private int hitCount;// 命中的次数
    private int missCount;// 丢失的次数
    /**

* 指定最大内存的LruCache构造方法

    public LruCache(int maxSize) {// 官方推荐maxSize一般声明为手机内存的1/8
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }
        this.maxSize = maxSize;
        this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
    }

    public void resize(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }
        synchronized (this) {
            this.maxSize = maxSize;
        }
        trimToSize(maxSize);

}

3、存放数据的方法：

public final V put(K key, V value) {    if (key == null || value == null) {        throw new NullPointerException("key == null || value == null");    }      V previous;      synchronized (this) {        // 记录 put 的次数        putCount++;        // 通过键值对，计算出要保存对象value的大小，并更新当前缓存大小        size += safeSizeOf(key, value);                //如果之前存在key，用新的value覆盖原来的数据        previous = map.put(key, value);        // 如果之前存在key，并且之前的value不为null        if (previous != null) {            // 计算出 之前value的大小，因为前面size已经加上了新的value数据的大小，此时，需要再次更新size，减去原来value的大小            size -= safeSizeOf(key, previous);        }      }    // 如果之前存在key，并且之前的value不为null    if (previous != null) {        /*         * previous值被剔除了，此次添加的 value 已经作为key的 新值         * 告诉 自定义 的 entryRemoved 方法         */        entryRemoved(false, key, previous, value);    }    //裁剪缓存容量（在当前缓存数据大小超过了总容量maxSize时，才会真正去执行LRU）    trimToSize(maxSize);      return previous;}

* 根据key查询缓存，如果该key对应的value存在于缓存，直接返回value；* 访问到这个结点时，LinkHashMap会将它移动到双向循环链表的的尾部。* 如果如果没有缓存的值，则返回null。*/public final V get(K key) {    if (key == null) {        throw new NullPointerException("key == null");    }    V mapValue;    synchronized (this) {        // LinkHashMap 如果设置按照访问顺序的话，这里每次get都会重整数据顺序        mapValue = map.get(key);        // 计算 命中次数        if (mapValue != null) {            hitCount++;            return mapValue;        }        // 计算 丢失次数        missCount++;    }    /*     * 官方解释：     * 尝试创建一个值，这可能需要很长时间，并且Map可能在create()返回的值时有所不同。如果在create()执行的时     * 候，用这个key执行了put方法，那么此时就发生了冲突，我们在Map中删除这个创建的值，释放被创建的值，保留put进去的值。     */    V createdValue = create(key);    if (createdValue == null) {        return null;    }    /*     * 实现了自定义的 create(K key) 逻辑     *      */    synchronized (this) {        // 记录 create 的次数        createCount++;        // 将自定义create创建的值，放入LinkedHashMap中，如果key已经存在，会返回 之前相同key 的值        mapValue = map.put(key, createdValue);        // 如果之前存在相同key的value，即有冲突。        if (mapValue != null) {            /*             * 有冲突             * 所以 撤销 刚才的 操作             * 将 之前相同key 的值 重新放回去             */            map.put(key, mapValue);        } else {            // 拿到键值对，计算出在容量中的相对长度，然后加上            size += safeSizeOf(key, createdValue);        }    }    // 如果上面 判断出了 将要放入的值发生冲突    if (mapValue != null) {        /*         * 刚才create的值被删除了，原来的 之前相同key 的值被重新添加回去了         * 告诉 自定义 的 entryRemoved 方法         */        entryRemoved(false, key, createdValue, mapValue);        return mapValue;    } else {        // 上面 进行了 size += 操作 所以这里要重整长度        trimToSize(maxSize);        return createdValue;    }}

1）先尝试从map缓存中获取value，即mapVaule = map.get(key);如果mapVaule != null，说明缓存中存在该对象，直接返回即可；

2）如果mapVaule == null，说明缓存中不存在该对象，大多数情况下会直接返回null；但是如果我们重写了create()方法，在缓存没有该数据的时候自己去创建一个，则会继续往下走，中间可能会出现冲突；

3）注意：在我们通过LinkedHashMap进行get(key)或put(key,value)时都会对链表进行调整，即将刚刚访问get或加入put的结点放入到链表尾部。

5、清除数据:

public void trimToSize(int maxSize) {    /*     * 循环进行LRU，直到当前所占容量大小没有超过指定的总容量大小     */    while (true) {        K key;        V value;        synchronized (this) {            // 一些异常情况的处理            if (size < 0 || (map.isEmpty() && size != 0)) {                throw new IllegalStateException(                        getClass().getName() + ".sizeOf() is reporting inconsistent results!");            }            // 首先判断当前缓存数据大小是否超过了指定的缓存空间总大小。如果没有超过，即缓存中还可以存入数据，直接跳出循环，清理完毕            if (size <= maxSize || map.isEmpty()) {                break;            }            /**             * 执行到这，表示当前缓存数据已超过了总容量，需要执行LRU，即将最近最少使用的数据清除掉，直到数据所占缓存空间没有超标;             * 根据前面的原理分析，知道，在链表中，链表的头结点是最近最少使用的数据，因此，最先清除掉链表前面的结点             */            Map.Entry<K, V> toEvict = map.entrySet().iterator().next();            key = toEvict.getKey();            value = toEvict.getValue();            map.remove(key);            // 移除掉后，更新当前数据缓存的大小            size -= safeSizeOf(key, value);            // 更新移除的结点数量            evictionCount++;        }        /*         * 通知某个结点被移除，类似于回调         */        entryRemoved(true, key, value, null);    }}  /**     * 移除已存在的元素实体     * Removes the entry for {@code key} if it exists.     * @return the previous value mapped by {@code key}.     */    public final V remove(K key) {        if (key == null) {            throw new NullPointerException("key == null");        }        V previous;        synchronized (this) {            previous = map.remove(key);            if (previous != null) {                size -= safeSizeOf(key, previous);            }        }        if (previous != null) {            entryRemoved(false, key, previous, null);        }        return previous;    }    ……    }

6、entryRemoved()

主要作用就是在结点数据value需要被删除或回收的时候，给开发者的回调。开发者就可以在这个方法里面实现一些自己的逻辑：

1）可以进行资源的回收；

2）可以实现二级内存缓存，可以进一步提高性能，思路如下：重写LruCache的entryRemoved()函数，把删除掉的item，再次存入另外一个LinkedHashMap<String, SoftWeakReference<Bitmap>>中，这个数据结构当做二级缓存，每次获得图片的时候，先判断LruCache中是否缓存，没有的话，再判断这个二级缓存中是否有，如果都没有再从sdcard上获取。sdcard上也没有的话，就从网络服务器上拉取。

entryRemoved()在LruCache中有四个地方进行了调用：put()、get()、trimToSize()、remove()中进行了调用。

二、磁盘缓存：--->DiskLruCache:

在DiskLruCache中，数据是缓存到了本地文件，这里的LinkedHashMap中的value只是保存的是value的一些简要信息Entry，如唯一的文件名称、大小、是否可读等信息

工作流程：

1）初始化：通过open()方法，获取DiskLruCache的实例，在open方法中通过readJournal(); 方法读取journal日志文件，根据journal日志文件信息建立map中的初始数据；然后再调用processJournal();方法对刚刚建立起的map数据进行分析，分析的工作，一个是计算当前有效缓存文件（即被CLEAN的）的大小，一个是清理无用缓存文件；

<span style="color:#555555;">public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize) throws IOException {        if(maxSize <= 0L) {            throw new IllegalArgumentException("maxSize <= 0");        } else if(valueCount <= 0) {            throw new IllegalArgumentException("valueCount <= 0");        } else {            File backupFile = new File(directory, "journal.bkp");            if(backupFile.exists()) {                File cache = new File(directory, "journal");                if(cache.exists()) {                    backupFile.delete();                } else {                    renameTo(backupFile, cache, false);                }            }            DiskLruCache cache1 = new DiskLruCache(directory, appVersion, valueCount, maxSize);            if(cache1.journalFile.exists()) {                try {                    cache1.</span><span style="color:#ff0000;">readJournal</span><span style="color:#555555;">();                    cache1.</span><span style="color:#ff0000;">processJournal</span><span style="color:#555555;">();                    return cache1;                } catch (IOException var8) {                    System.out.println("DiskLruCache " + directory + " is corrupt: " + var8.getMessage() + ", removing");                    cache1.delete();                }            }            directory.mkdirs();            cache1 = new DiskLruCache(directory, appVersion, valueCount, maxSize);            cache1.rebuildJournal();            return cache1;        }    }</span>

2）数据缓存与获取缓存：上面的初始化工作完成后，我们就可以在程序中进行数据的缓存功能和获取缓存的功能了；

缓存数据的操作是借助DiskLruCache.Editor这个类完成的，这个类也是不能new的，需要调用DiskLruCache的edit()方法来获取实例，在写入完成后，需要进行commit（）；

注意每次调用edit()时，会向journal日志文件写入DIRTY为前缀的一条记录；文件保存成功后，调用commit()时，也会向journal日志中写入一条CLEAN为前缀的一条记录，如果失败，需要调用abort()，abort()里面会向journal文件写入一条REMOVE为前缀的记录。

3）合适的地方进行flush()

在上面进行数据缓存或获取缓存的时候，调用不同的方法会往journal中写入不同前缀的一行记录，记录写入是通过IO下的Writer写入的，要真正生效，还需要调用writer的flush()方法，而DiskLruCache中的flush()方法中封装了writer.flush()的操作，因此，我们只需要在合适地方调用DiskLruCache中的flush()方法即可。其作用也就是将操作记录同步到journal文件中，这是一个消耗效率的IO操作，我们不用每次一往journal中写数据后就调用flush，这样对效率影响较大，可以在Activity的onPause()中调用一下即可。

 private synchronized void completeEdit(DiskLruCache.Editor editor, boolean success) throws IOException {        DiskLruCache.Entry entry = editor.entry;        if(entry.currentEditor != editor) {            throw new IllegalStateException();        } else {            int i;            if(success && !entry.readable) {                for(i = 0; i < this.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(i = 0; i < this.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;                        this.size = this.size - oldLength + newLength;                    }                } else {                    deleteIfExists(dirty);                }            }            ++this.redundantOpCount;            entry.currentEditor = null;            if(entry.readable | success) {                entry.readable = true;                this.journalWriter.append("CLEAN");                this.journalWriter.append(' ');                this.journalWriter.append(entry.key);                this.journalWriter.append(entry.getLengths());                this.journalWriter.append('\n');                if(success) {                    entry.sequenceNumber = (long)(this.nextSequenceNumber++);                }            } else {                this.lruEntries.remove(entry.key);                this.journalWriter.append("REMOVE");                this.journalWriter.append(' ');                this.journalWriter.append(entry.key);                this.journalWriter.append('\n');            }            this.journalWriter.flush();            if(this.size > this.maxSize || this.journalRebuildRequired()) {                this.executorService.submit(this.cleanupCallable);            }        }    }

0 0