转载请标明出处：一片枫叶的专栏

android开发过程中常常会用到缓存。如今主流的app中图片等资源的缓存策略通常是分两级。一个是内存级别的缓存，一个是磁盘级别的缓存。

作为android系统的维护者google也开源了其缓存方案，LruCache和DiskLruCache。从android3.1開始LruCache已经作为android源代码的一部分维护在android系统中。为了兼容曾经的版本号android的support-v4包也提供了LruCache的维护，假设App须要兼容到android3.1之前的版本号就须要使用support-v4包中的LruCache，假设不须要兼容到android3.1则直接使用android源代码中的LruCache就可以，这里须要注意的是DiskLruCache并非android源代码的一部分。

在LruCache的源代码中。关于LruCache有这种一段介绍：

A cache that holds strong references to a limited number of values. Each time a value is accessed, it is moved to the head of a queue. When a value is added to a full cache, the value at the end of that queue is evicted and may become eligible for garbage collection.

cache对象通过一个强引用来訪问内容。每次当一个item被訪问到的时候，这个item就会被移动到一个队列的队首。当一个item被加入到已经满了的队列时，这个队列的队尾的item就会被移除。

事实上这个实现的过程就是LruCache的缓存策略。即Lru–>(Least recent used)最少近期使用算法。

以下我们详细看一下LruCache的实现：

public class LruCache<K, V> {

    private final LinkedHashMap<K, V> map;

    /** Size of this cache in units. Not necessarily the number of elements. */

    private int size;

    private int maxSize;

    private int putCount;

    private int createCount;

    private int evictionCount;

    private int hitCount;

    private int missCount;

    /**

     * @param maxSize for caches that do not override {@link #sizeOf}, this is

     *     the maximum number of entries in the cache. For all other caches,

     *     this is the maximum sum of the sizes of the entries in this cache.

     */

    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);

    }

    /**

     * Sets the size of the cache.

     *

     * @param maxSize The new maximum size.

     */

    public void resize(int maxSize) {

        if (maxSize <= 0) {

            throw new IllegalArgumentException("maxSize <= 0");

        }

        synchronized (this) {

            this.maxSize = maxSize;

        }

        trimToSize(maxSize);

    }

    /**

     * Returns the value for {@code key} if it exists in the cache or can be

     * created by {@code #create}. If a value was returned, it is moved to the

     * head of the queue. This returns null if a value is not cached and cannot

     * be created.

     */

    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++;

        }

        /*

         * Attempt to create a value. This may take a long time, and the map

         * may be different when create() returns. If a conflicting value was

         * added to the map while create() was working, we leave that value in

         * the map and release the created value.

         */

        V createdValue = create(key);

        if (createdValue == null) {

            return null;

        }

        synchronized (this) {

            createCount++;

            mapValue = map.put(key, createdValue);

            if (mapValue != null) {

                // There was a conflict so undo that last put

                map.put(key, mapValue);

            } else {

                size += safeSizeOf(key, createdValue);

            }

        }

        if (mapValue != null) {

            entryRemoved(false, key, createdValue, mapValue);

            return mapValue;

        } else {

            trimToSize(maxSize);

            return createdValue;

        }

    }

    /**

     * Caches {@code value} for {@code key}. The value is moved to the head of

     * the queue.

     *

     * @return the previous value mapped by {@code key}.

     */

    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);

            if (previous != null) {

                size -= safeSizeOf(key, previous);

            }

        }

        if (previous != null) {

            entryRemoved(false, key, previous, value);

        }

        trimToSize(maxSize);

        return previous;

    }

    /**

     * Remove the eldest entries until the total of remaining entries is at or

     * below the requested size.

     *

     * @param maxSize the maximum size of the cache before returning. May be -1

     *            to evict even 0-sized elements.

     */

    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) {

                    break;

                }

                Map.Entry<K, V> toEvict = map.eldest();

                if (toEvict == null) {

                    break;

                }

                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;

    }

    /**

     * Called for entries that have been evicted or removed. This method is

     * invoked when a value is evicted to make space, removed by a call to

     * {@link #remove}, or replaced by a call to {@link #put}. The default

     * implementation does nothing.

     *

     * <p>The method is called without synchronization: other threads may

     * access the cache while this method is executing.

     *

     * @param evicted true if the entry is being removed to make space, false

     *     if the removal was caused by a {@link #put} or {@link #remove}.

     * @param newValue the new value for {@code key}, if it exists. If non-null,

     *     this removal was caused by a {@link #put}. Otherwise it was caused by

     *     an eviction or a {@link #remove}.

     */

    protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {}

    /**

     * Called after a cache miss to compute a value for the corresponding key.

     * Returns the computed value or null if no value can be computed. The

     * default implementation returns null.

     *

     * <p>The method is called without synchronization: other threads may

     * access the cache while this method is executing.

     *

     * <p>If a value for {@code key} exists in the cache when this method

     * returns, the created value will be released with {@link #entryRemoved}

     * and discarded. This can occur when multiple threads request the same key

     * at the same time (causing multiple values to be created), or when one

     * thread calls {@link #put} while another is creating a value for the same

     * key.

     */

    protected V create(K key) {

        return null;

    }

    private int safeSizeOf(K key, V value) {

        int result = sizeOf(key, value);

        if (result < 0) {

            throw new IllegalStateException("Negative size: " + key + "=" + value);

        }

        return result;

    }

    /**

     * Returns the size of the entry for {@code key} and {@code value} in

     * user-defined units.  The default implementation returns 1 so that size

     * is the number of entries and max size is the maximum number of entries.

     *

     * <p>An entry's size must not change while it is in the cache.

     */

    protected int sizeOf(K key, V value) {

        return 1;

    }

    /**

     * Clear the cache, calling {@link #entryRemoved} on each removed entry.

     */

    public final void evictAll() {

        trimToSize(-1); // -1 will evict 0-sized elements

    }

    /**

     * For caches that do not override {@link #sizeOf}, this returns the number

     * of entries in the cache. For all other caches, this returns the sum of

     * the sizes of the entries in this cache.

     */

    public synchronized final int size() {

        return size;

    }

    /**

     * For caches that do not override {@link #sizeOf}, this returns the maximum

     * number of entries in the cache. For all other caches, this returns the

     * maximum sum of the sizes of the entries in this cache.

     */

    public synchronized final int maxSize() {

        return maxSize;

    }

    /**

     * Returns the number of times {@link #get} returned a value that was

     * already present in the cache.

     */

    public synchronized final int hitCount() {

        return hitCount;

    }

    /**

     * Returns the number of times {@link #get} returned null or required a new

     * value to be created.

     */

    public synchronized final int missCount() {

        return missCount;

    }

    /**

     * Returns the number of times {@link #create(Object)} returned a value.

     */

    public synchronized final int createCount() {

        return createCount;

    }

    /**

     * Returns the number of times {@link #put} was called.

     */

    public synchronized final int putCount() {

        return putCount;

    }

    /**

     * Returns the number of values that have been evicted.

     */

    public synchronized final int evictionCount() {

        return evictionCount;

    }

    /**

     * Returns a copy of the current contents of the cache, ordered from least

     * recently accessed to most recently accessed.

     */

    public synchronized final Map<K, V> snapshot() {

        return new LinkedHashMap<K, V>(map);

    }

    @Override public synchronized final String toString() {

        int accesses = hitCount + missCount;

        int hitPercent = accesses != 0 ? (100 * hitCount / accesses) : 0;

        return String.format("LruCache[maxSize=%d,hits=%d,misses=%d,hitRate=%d%%]",

                maxSize, hitCount, missCount, hitPercent);

    }

}

能够看到LruCache初始化的时候须要使用泛型，一般的我们这样初始化LruCache对象：

// 获取应用程序最大可用内存

        int maxMemory = (int) Runtime.getRuntime().maxMemory();

        int cacheSize = maxMemory / 8;

        // 设置图片缓存大小为程序最大可用内存的1/8

        mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {

            @Override

            protected int sizeOf(String key, Bitmap bitmap) {

                return bitmap.getByteCount();

            }

        };  

这里我们假设通过String作为key保存bitmap对象，同一时候须要传递一个int型的maxSize数值。主要用于设置LruCache链表的最大值。

查看其构造方法：

// 获取应用程序最大可用内存

        int maxMemory = (int) Runtime.getRuntime().maxMemory();

        int cacheSize = maxMemory / 8;

        // 设置图片缓存大小为程序最大可用内存的1/8

        mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {

            @Override

            protected int sizeOf(String key, Bitmap bitmap) {

                return bitmap.getByteCount();

            }

        };  

能够看到其基本的是初始化了maxSize和map链表对象。

然后查看put方法：

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);

            if (previous != null) {

                size -= safeSizeOf(key, previous);

            }

        }

        if (previous != null) {

            entryRemoved(false, key, previous, value);

        }

        trimToSize(maxSize);

        return previous;

    }

须要传递两个參数：K和V，首先做了一下參数的推断，然后定义一个保存前一个Value值得暂时变量。让putCount（put运行的次数）自增，让map的size大小自增。

须要注意的是这里的

previous = map.put(key, value);

我们看一下这里的map.put（）的详细实现：

@Override public V put(K key, V value) {

        if (key == null) {

            return putValueForNullKey(value);

        }

        int hash = Collections.secondaryHash(key);

        HashMapEntry<K, V>[] tab = table;

        int index = hash & (tab.length - 1);

        for (HashMapEntry<K, V> e = tab[index]; e != null; e = e.next) {

            if (e.hash == hash && key.equals(e.key)) {

                preModify(e);

                V oldValue = e.value;

                e.value = value;

                return oldValue;

            }

        }

        // No entry for (non-null) key is present; create one

        modCount++;

        if (size++ > threshold) {

            tab = doubleCapacity();

            index = hash & (tab.length - 1);

        }

        addNewEntry(key, value, hash, index);

        return null;

    }

将Key与Value的值压入Map中，这里推断了一下假设map中已经存在该key，value键值对，则不再压入map，并将Value值返回，否则将该键值对压入Map中。并返回null；

返回继续put方法：

previous = map.put(key, value);

            if (previous != null) {

                size -= safeSizeOf(key, previous);

            }

能够看到这里我们推断map.put方法的返回值是否为空。假设不为空的话，则说明我们刚刚并没有将我么你的键值对压入Map中，所以这里的size须要自减；

然后以下：

if (previous != null) {

            entryRemoved(false, key, previous, value);

        }

这里推断previous是否为空，假设不为空的话，调用了一个空的实现方法entryRemoved()，也就是说我们能够实现自己的LruCache并在加入缓存的时候若存在该缓存能够重写这种方法；

以下调用了trimToSize(maxSize)方法：

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) {

                    break;

                }

                Map.Entry<K, V> toEvict = map.eldest();

                if (toEvict == null) {

                    break;

                }

                key = toEvict.getKey();

                value = toEvict.getValue();

                map.remove(key);

                size -= safeSizeOf(key, value);

                evictionCount++;

            }

            entryRemoved(true, key, value, null);

        }

    }

该方法主要是推断该Map的大小是否已经达到阙值，若达到，则将Map队尾的元素（最不常使用的元素）remove掉。

总结：

LruCache put方法，将键值对压入Map数据结构中。若这是Map的大小已经大于LruCache中定义的最大值，则将Map中最早压入的元素remove掉；

查看get方法：

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++;

        }

        /*

         * Attempt to create a value. This may take a long time, and the map

         * may be different when create() returns. If a conflicting value was

         * added to the map while create() was working, we leave that value in

         * the map and release the created value.

         */

        V createdValue = create(key);

        if (createdValue == null) {

            return null;

        }

        synchronized (this) {

            createCount++;

            mapValue = map.put(key, createdValue);

            if (mapValue != null) {

                // There was a conflict so undo that last put

                map.put(key, mapValue);

            } else {

                size += safeSizeOf(key, createdValue);

            }

        }

        if (mapValue != null) {

            entryRemoved(false, key, createdValue, mapValue);

            return mapValue;

        } else {

            trimToSize(maxSize);

            return createdValue;

        }

    }

能够看到參数值为Key。简单的理解就是通过key值从map中取出Value值。

详细来说，推断map中是否含有key值value值。若存在。则hitCount（击中元素数量）自增，并返回Value值。若没有击中，则运行create(key)方法，这里看到create方法是一个空的实现方法，返回值为null。所以我们能够重写该方法，在调用get（key）的时候若没有找到value值，则自己主动创建一个value值并压入map中。

总结：

• LruCache，内部使用Map保存内存级别的缓存

• LruCache使用泛型能够设配各种类型

• LruCache使用了Lru算法保存数据（最短最少使用least recent use）

• LruCache仅仅用使用put和get方法压入数据和取出数据

另外对android源代码解析方法感兴趣的可參考我的：

android源代码解析之（一）–>android项目构建过程

android源代码解析之（二）–>异步消息机制

android源代码解析之（三）–>异步任务AsyncTask

android源代码解析之（四）–>HandlerThread

android源代码解析之（五）–>IntentService

android源代码解析之（六）–>Log

本文以同步至github中：https://github.com/yipianfengye/androidSource。欢迎star和follow