LruCache的终极解析

LruCache是android提供的一个常用而且有用的数据缓存工具类,通其中是通过键值对来保存数据.对于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.

  其大意是:LruCache是一个通过强引用来保存一定数量的数据的缓存技术.每次使用一个数据时候,这个数据就会被移动到队列的最前面(这样维护来一个访问数据的顺序).当新加一个数据到这个已经满了的缓存时候,这个缓存里面最后面的数据(最不常使用的数据)就会被清理掉.

   通过上面的说明,基本可以知道LruCache作用和实现方法,不过仅仅上面的说明要深刻理解其中奥秘还是优点困难.上面有四处标记红色的地方,下面通过对这四处红色文字做以下说明.

   (1)"一定数量的数据": 这里的"一定数量"通常是指LruCache缓存数据的数量(个数),也就是说LruCache缓存的键值对数据的个数.注意,这里我说的是"通常".当然也有其他情况:也可以是缓存数据所占用的内存的size(其单位一般时k,当然byte都可以),这个时候,你就需要重写LruCache的这个方法:sizeOf(K key, V value)来计算每一个键值对数据所占用的内存:

    private static LruCache<Integer, Drawable> createIconCache() {
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        final int cacheSize = maxMemory / 8;
        return new LruCache<Integer, Drawable>(cacheSize) {
            protected int sizeOf(Integer key, Drawable drawable) {
                if (drawable instanceof BitmapDrawable) {//计算一个这个BitmapDrawable占用内存
                    Bitmap bitmap = ((BitmapDrawable) drawable).getBitmap();
                    return bitmap.getByteCount() / 1024;
                }
                return 1;//否则返回1,默认情况下返回的就是1
            }
        };
    }

   上面的代码时候创建一个缓存Drawable 的图片数据的LruCache 对象,在方法sizeOf 里面判断,如果当前缓存的是BitmapDrawable 类型的图片数据,则返回的就是这个图片的内存大小,否则返回1.

   很明显,当sizeOf方法返回1的时候,就表示当前的LruCache缓存的数据数量是指键值对数量.下面来看看LruCache中sizeOf方法默认是如何定义的:

protected int sizeOf(K key, V value) {
        return 1;
    }

   默认情况下就是返回1的.所以如果你的 LruCache缓存数据如果时图片并且/或者对缓存的数据的内存大小有限制的时候,就需要重写这个方法sizeOf(K key, V value)

 (2)这个数据就会被移动到队列的最前面(这样维护来一个访问数据的顺序):其实很快可以知道,hashmap中的LinkedHashMap似乎就可以实现这个功能,LruCache当然也就使用来LinkedHashMap,来看看LruCache的构造方法就清楚了:

    public LruCache(int maxSize) {//这里maxSize是指当前LruCache缓存数据最大量
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }
        this.maxSize = maxSize;
        this.map = new LinkedHashMap<K, V>(0, 0.75f, true);//初始化一个LinkedHashMap,并且第三个参数是true,这表明这个LinkedHashMap是按照按访问顺序排序的.
    }

(3) 已经满了的缓存:每次使用 LruCache的时候:调用put(K key, V value)或者调用get(K key) 时候都会调用trimToSize(int maxSize)检测一下 LruCache是否已经满了.

(4)被清理掉:同上面一样,在调用trimToSize检测是否已经满来的时候,如果已经满来就会清理掉,看看源码:

    public void trimToSize(int maxSize) {
        while (true) {//一个死循环:直到当前LruCache没有满才会跳出这个循环
            K key;
            V value;
            synchronized (this) {
                if (size < 0 || (map.isEmpty() && size != 0)) {//异常错误检测:当前已经缓存的数据数量不能为负数,并且没有数据的时候其数据数量不能大于0
                    throw new IllegalStateException(getClass().getName()
                            + ".sizeOf() is reporting inconsistent results!");
                }

                if (size <= maxSize) {//如果已经缓存的数据数量小于最大容量(没有满),则跳出循环
                    break;
                }

                Map.Entry<K, V> toEvict = map.eldest();//通过LinkedHashMap来获取最不常用的一个键值对数据
                if (toEvict == null) {
                    break;
                }

                key = toEvict.getKey();
                value = toEvict.getValue();
                map.remove(key);  //删除这个数据
                size -= <span style="color:#FF0000;">safeSizeOf</span>(key, value); //获取这个删除的键值对数据所占用的容量(有可能是1,也有可能是计算的图片占用的内存,也有可能是其他)
                evictionCount++;
            }

            <span style="color:#FF0000;">entryRemoved</span>(true, key, value, null); //回调用entryRemoved,一般用于通知客户端,这个键值对数据已经被清理出LruCache了
        }
    }	

上面的说明已经很清楚了,不过红色标识的两个方法需要下面来说说:

• <span style="color:#FF0000;">safeSizeOf<span style="color:#000000;">来看看函数原型:</span></span>

      private int safeSizeOf(K key, V value) {
          int result = sizeOf(key, value);
          if (result < 0) {
              throw new IllegalStateException("Negative size: " + key + "=" + value);
          }
          return result;
      }

  看到了吗,其实就是调用了sizeOf这个方法.
•  entryRemoved 来看看函数原型:   protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {} 是一个空的函数,其实这个方法时给子类重写的,如果你想要知道你的LruCache在悄悄删除数据的时候能够告知你的话,你就需要重写这个方法,比如:你创建一个存储bitmap的数据的LruCache,你可能想要在LruCache清理掉这个数据的时候,自己再调用这个bitmap的recycle()来是否资源的话,你就需要重写entryRemoved了.

       到了这里,应该对LruCache比较了解,不过一个问题由此出来了,不知道大家有没有想到:既然LruCache会自己清理掉最不常用的键值对数据,可是最不常用也不代表就不会使用呀!如果,突然使用了已经被清理掉的键值对数据这么办!

      举个例子:我的listview来显示100个菜单项,每一个菜单项来显示一个图片,每一个图片都有100k大小,我的LruCache最大容量只有1000k,这样一来当我滑动菜单的时候肯定LruCache会清除掉很多图片.那这么办呢?如果我能够知道已经清理掉的数据需要再次使用就可以了,那我可以重新创建.

      为了解决这个问题,LruCache里面的方法get(K key)会去检测当前获取的数据是否为null,如果是null,则调用方法create来创建.默认情况下create这个方法直接返回 null;所以你自己的LruCache 是需要重写这个方法的.下面来看看get(K key)方法的源码:

    public final V get(K key) {//通过key来获取存储的数据
        if (key == null) {
            throw new NullPointerException("key == null");
        }

        V mapValue;
        synchronized (this) {
            mapValue = map.get(key);//其实是通过LinkedHashMap来获取的
            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);//如果当前<font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><span style="color:#FF0000;"><span style="color:#000000;"><span style="color:#FF0000;">LruCache</span></span></span></font></font></font></font></font></font>没有这个数据,则调用create创建
        if (createdValue == null) {
            return null;
        }

        synchronized (this) {
            createCount++;//更新自己创建的数量
            mapValue = map.put(key, createdValue);//将新创建的数据加入到LinkedHashMap里面

            if (mapValue != null) {
                // There was a conflict so undo that last put
                map.put(key, mapValue);//如果冲突来再次尝试
            } else {
                size += safeSizeOf(key, createdValue);//更新当前<font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><span style="color:#FF0000;"><span style="color:#000000;"><span style="color:#FF0000;">LruCache</span></span></span></font></font></font></font></font></font> 已经存储数据的数量
            }
        }

        if (mapValue != null) {
            entryRemoved(false, key, createdValue, mapValue);//调用entryRemoved通知已经清理掉了一个数据
            return mapValue;
        } else {
            trimToSize(maxSize);//检测是否已经满了
            return createdValue;
        }
    }

   说道到这里 ,我想已经说的很清楚了. LruCache 这个工具类其实比较简单的.除了上面我说的特点外,还有其他的一些不太常用的东西,下面来看看里面的几个源方法:  

     public final V put(K key, V value) {//往<font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><span style="color:#FF0000;"><span style="color:#000000;"><span style="color:#FF0000;">LruCache</span></span></span></font></font></font></font></font></font></font></font></font></font>里面加入数据
        if (key == null || value == null) {

            throw new NullPointerException("key == null || value == null");
        }

        V previous;
        synchronized (this) {
            putCount++;//加入数据个数的更新
            size += safeSizeOf(key, value);//<font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><font color="#FF0000"><font color="#000000"><span style="color:#FF0000;"><span style="color:#000000;"><span style="color:#FF0000;">LruCache</span></span></span></font></font></font></font></font></font></font></font></font></font> 存储数据的数量更新
            previous = map.put(key, value);
            if (previous != null) {
                size -= safeSizeOf(key, previous);
            }
        }

        if (previous != null) {
            entryRemoved(false, key, previous, value);
        }

        trimToSize(maxSize);检测是否已经满了
        return previous;
    }

    public final void evictAll() {//清理掉所有数据
        trimToSize(-1); // -1 will evict 0-sized elements
    }