Volley之ByteArrayPool——LruCache实现

基础

        其主要作用是byte[]的缓存池，可以指定最大的缓存的byte数目。当缓存的byte数目超过指定的最大值时，以LRU策略进行回收。在频繁进行I/O操作时，如果不停地创建byte[]，会导致堆内存的极速消耗，因为gc的回收并不是太及时。

原理

        用一个有序集合存储缓存的byte[]，用另一个集合存储待删的byte[]——在缓存池满了的时候删除该集合中的最前面元素，直到缓存池有空闲为止。

源码及注释

import java.util.ArrayList;import java.util.Collections;import java.util.Comparator;import java.util.LinkedList;import java.util.List;/** * byte[]的缓存池，可以指定最大的缓存的byte数目。当缓存的byte数目超过指定的最大值时，以LRU策略进行回收。 * 用一个集合记录该byte[]的使用顺序，使用另一个集合记录已经使用过的byte[]，保证对byte[]的重复利用。 */public class ByteArrayPool {    /**     * byte[]待删集合，记录了byte[]的使用顺序。当缓存的byte数目超过指定的最大值时，会回收该list集合中的第一个元素。     * 每一次从变量mBuffersBySize中获取到合适的byte[]时，会将返回值从该集合中删除，因为这个byte[]是最近使用的。     * 每一次回收该集合中第0个元素，保证了回收的byte[]是使用时间最久远的。     */    private List<byte[]> mBuffersByLastUse = new LinkedList<>();    /**     * byte[]的真正缓存list集合。每一次获取时都是从该集合中获取或者新生成     */    private List<byte[]> mBuffersBySize = new ArrayList<>(64);    /**     * 当前缓存池中已经有byte数     */    private int mCurrentSize = 0;    /**     * 本缓存池中最大的缓存byte数     */    private final int mSizeLimit;    /**      * 哪个byte数组元素少，哪个在前     */    protected static final Comparator<byte[]> BUF_COMPARATOR = new Comparator<byte[]>() {        @Override        public int compare(byte[] lhs, byte[] rhs) {            return lhs.length - rhs.length;        }    };    public ByteArrayPool(int sizeLimit) {        mSizeLimit = sizeLimit;    }    /**     * @param len.返回的byte[]的最小长度，有可能返回的byte[]的长度大于该len     */    public synchronized byte[] getBuf(int len) {        for (int i = 0; i < mBuffersBySize.size(); i++) {            byte[] buf = mBuffersBySize.get(i);            if (buf.length >= len) {                mCurrentSize -= buf.length;//返回后，将当前缓存池中缓存的byte数目减少                mBuffersBySize.remove(i);//删掉，保证了一个byte[]数组不会提供给两个客户端使用                //本次使用了该缓存，所以将其从待删集合中删除，这样即使缓存的byte数量超过最大的范围，也不会被删掉。保证了最新的不会被删。                //同时，当一个byte[]被多次使用时，则该byte[]会被存储到该集合的最后端，也不会被立即回收                mBuffersByLastUse.remove(buf);                return buf;            }        }        return new byte[len];//没有合适的或者第一次会直接返回    }    /**     * 将使用过的byte数组返回到缓存池中     */    public synchronized void returnBuf(byte[] buf) {        if (buf == null || buf.length > mSizeLimit) {            return;        }        mBuffersByLastUse.add(buf);//待删集合，不能对回收的byte[]进行排序        //该二分查找的返回值有两个效果：其一知道查找的有木有，其二如果木有，插入时插入的位置。        int pos = Collections.binarySearch(mBuffersBySize, buf, BUF_COMPARATOR);        if (pos < 0) {            pos = -pos - 1;        }        mBuffersBySize.add(pos, buf);        mCurrentSize += buf.length;        trim();    }    /**     * 回收该回收的部分。     */    private synchronized void trim() {        while (mCurrentSize > mSizeLimit) {            byte[] buf = mBuffersByLastUse.remove(0);            mBuffersBySize.remove(buf);            mCurrentSize -= buf.length;        }    }}

        主要思路都在注释中。其实其主要思路就是：将最新使用的放在mBuffersByLastUse的最后面，这样回收的就最晚。而且LruCache的实现思路也和这个完全一样。

LruCache

import java.util.LinkedHashMap;import java.util.Map;public class LruCache<K, V> {    private final LinkedHashMap<K, V> map;//使用LinkedHashMap的主要原因在于：它的put的顺序与迭代器的取的顺序一致。    /** 最大的缓存数*/    private int size;    private int maxSize;    private int putCount;    private int createCount;    private int evictionCount;    private int hitCount;    private int missCount;    public LruCache(int maxSize) {        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);    }    public final V get(K key) {        if (key == null) {            throw new NullPointerException("key == null");        }        V mapValue;        synchronized (this) {            mapValue = map.get(key);            if (mapValue != null) {                hitCount++;                return mapValue;            }            missCount++;        }        /*         * 通过key值获取value值。如果该key值对应的有value了，则放弃create()返回的值。 * 因为create()可能耗费的时间比较长，所以create()执行完毕后，key可能对应的有value。         */        V createdValue = create(key);        if (createdValue == null) {            return null;        }        synchronized (this) {            createCount++;            mapValue = map.put(key, createdValue);            if (mapValue != null) {                // key值有冲突，放弃create()生成的value                map.put(key, mapValue);            } else {                size += safeSizeOf(key, createdValue);            }        }        if (mapValue != null) {            entryRemoved(false, key, createdValue, mapValue);            return mapValue;        } else {            trimToSize(maxSize);            return createdValue;        }    }    /**      * 这里是先将数据加入缓存中，再判断缓存的大小是否超过了限制。     * 这会导致在临界状态下依旧会OOM，可以先移除多余的部分，再将新的加入到缓存中。     */    public final V put(K key, V value) {        if (key == null || value == null) {            throw new NullPointerException("key == null || value == null");        }        V previous;        synchronized (this) {            putCount++;            size += safeSizeOf(key, value);            previous = map.put(key, value);//返回key对应的value。            if (previous != null) {                size -= safeSizeOf(key, previous);//previous是要被删除的，所以size应减除previous的大小            }        }        if (previous != null) {            entryRemoved(false, key, previous, value);        }        trimToSize(maxSize);        return previous;    }    /**     * 移除存在时间最久的对象，直到缓存的大小不大于最大缓存范围     * 整理整个缓存池，防止超出最大的范围     */    public void trimToSize(int maxSize) {        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;                }//因为获取的顺序与存储的顺序一致，所以该句得到的就是存在时间最久的缓存对象。                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);        }    }    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;    }    /**     * oldValue从缓存池中移除时的回调     */    protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {}    /**     * 根据key值生成value。     */    protected V create(K key) {        return null;    }/** * 对sizeOf()的大小加一层判断而已 */    private int safeSizeOf(K key, V value) {        int result = sizeOf(key, value);        if (result < 0) {            throw new IllegalStateException("Negative size: " + key + "=" + value);        }        return result;    }    /**     * 获取对应value的大小。一般都需要重写该方法     */    protected int sizeOf(K key, V value) {        return 1;    }    /**     * trimToSize()传入-1，则所有的缓存对象都会被清除     */    public final void evictAll() {        trimToSize(-1); // -1 will evict 0-sized elements    }    //剩余代码无意义，略}