android之LruCache源码解析

标签：android开发   frameworks   源码   缓存   cache   

移动设备开发中,由于移动设备(手机等)的内存有限,所以使用有效的缓存技术是必要的.android提供来一个缓存工具类LruCache,开发中我们会经常用到,下面来他是如何实现的.

在package android.util包里面有对LruCache定义的java文件.为了能准确的理解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的工作原理.下面来一步一步说明他的具体实现:

      (1)如何实现保存的数据是有一定顺序的,并且使用过一个存在的数据,这个数据就会被移动到数据队列的头部.这里采用的是LinkedHashMap.

          我们知道LinkedHashMap是保存一个键值对数据的,并且可以维护这些数据相应的顺序的.一般可以保证存储的数据按照存入的顺序或者使用的顺序的.下面来看看LruCache的构造方法:

    public LruCache(int maxSize) {//指定缓存数据的数量
        if (maxSize <= 0) {//必须大于0
            throw new IllegalArgumentException("maxSize <= 0");
        }
        this.maxSize = maxSize;
        this.map = new LinkedHashMap<K, V>(0, 0.75f, true);//创建一个LinkedHashMap,并且按照访问数据的顺序排序    
    }

      答案是:都是. 可以是缓存数据的个数,也可以使缓存数据所占用内存总量,当然也可以是其他.到底是什么,需要看你的LruCache如何重写这个方法:sizeOf(K key, V value)

    protected int sizeOf(K key, V value) {//子类覆盖这个方法来计算出自己的缓存对于每一个保存的数据所占用的量
        return 1;//默认返回1,这说明:默认情况下缓存的数量就是指缓存数据的总个数(每一个数据都是1).
    }

 * <p>By default, the cache size is measured in the number of entries. Override
 * {@link #sizeOf} to size the cache in different units. For example, this cache
 * is limited to 4MiB of bitmaps:
 * <pre>   {@code
 *   int cacheSize = 4 * 1024 * 1024; // 4MiB
 *   LruCache<String, Bitmap> bitmapCache = new LruCache<String, Bitmap>(cacheSize) {//保存bitmap的LruCache,容量是4M
 *       protected int sizeOf(String key, Bitmap value) {
 *           return value.getByteCount();//计算每一个缓存的图片所占用内存大小
 *       }
 *   }}</pre>

        其实在LruCache里面有一个方法:trimToSize()就是用来检测一次当前是否已经满,如果满来就自动移除一个数据,一直到不满为止:

    public void trimToSize(int maxSize) {//默认情况下传入是上面说的最大容量的值 this.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);//用来通知这个数据已经被移除,如果你需要知道一个数据何时被移除你需要从写这个方法entryRemoved
        }
    }

      下面的问题是:trimToSize这个方法何时调用呢?

       trimToSize这个方法在LruCache里面多个方法里面会被调用来检测是否已经满了,比如在往LruCache里面加入一个新的数据的方法put里面,还有在通过get(K key)这个方法获取一个数据的时候等,都会调用trimToSize来检测一次.下了来看看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;
    }

      (5)其实你应该马上有一个疑问:如果LruCache中已经删除了一个数据,可是现在又调用LruCache的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;
        }
    }

    protected V create(K key) {
        return null;
    }

android之LruCache源码解析

标签：android开发   frameworks   源码   缓存   cache   

原文地址：http://blog.csdn.net/green_shing/article/details/46714431