关于universal-image-loader中的几种内存缓存策略

说到图片缓存，做android开发的人想必都很了解universal-image-loader这个开源框架，最近有时间把cache包里面各种缓存实现看了下，在这里对内存方面的缓存进行一个简单的总结。

首先了解一下里面主要的类：LimitedMemoryCache，基本上所有的缓存都是基于这个类进行的。它会根据你传进来的值进行缓存空间大小的设制，超过这个值之后将进行数据的清理，把内容删除到小于设定的值为止。核心代码如下：

@Override
    public boolean put(String key, Bitmap value) {
        boolean putSuccessfully = false;
        // Try to add value to hard cache
        int valueSize = getSize(value);
        int sizeLimit = getSizeLimit();
        int curCacheSize = cacheSize.get();
        if (valueSize < sizeLimit) {
            while (curCacheSize + valueSize > sizeLimit) {
                Bitmap removedValue = removeNext();//抽象方法，由子类实现
                if (hardCache.remove(removedValue)) {
                    curCacheSize = cacheSize.addAndGet(-getSize(removedValue));
                }
            }
            hardCache.add(value);
            cacheSize.addAndGet(valueSize);

            putSuccessfully = true;
        }
        // Add value to soft cache
        super.put(key, value);
        return putSuccessfully;
    }

存放一张图片到内存里面的时候，会对当前已经缓存的图片大小总和即将要进行缓存的图片进行求和，通过removeNext()方法进行删除图片，每删除一次进行一次检查，直到总大小小于设定值的大小才进行缓存加载。对于这个removeNext抽象方法由子类来进行实现，删除的方式多种多样，可以按照各种算法随便发挥，了解到这个核思想之后，我们开始来介绍几种实现了这个类的缓存方案。

1.LRUMemoryCache： LRU（Least Recently Use），最近最少使用的缓存方式，就是缓存的大小超过一定的值之后，将会删除最近使用最少的那张图片。要使用这个缓存方式，我们先要了解一下LinkedHashMap，链式的哈西表，数据保存时使用的简和值都使用他们对应的哈西编码，然后使用一个双循环链表结构进行顺序维护，HashMap是一个散列存储，都是无序的，读取效率很高。LinkedHashMap在其基础上添加了一个双链表进行顺序的维护。然后我们的LRU算法也基本上都是这个存储结构实现。

private final Map<String, Bitmap> lruCache = Collections.synchronizedMap(new LinkedHashMap<String, Bitmap>(INITIAL_CAPACITY, LOAD_FACTOR, true));

要实现这个使用顺序维护，就要使用这个构造方法了，第一个参数是初始化容器大小，但是实际申请的大小空间会是这么一个关系：2的n次方>=INITIAL_CAPACITY , 在满足这个关系的前提下，取n的最小值。在INITIAL_CAPACITY==0的情况下比较特殊，这时候容器大小是2。LOAD_FACTOR是在容器中存放数量超过长度的这个比例时，容器将自动扩容为之前的两倍，第三个参数设置为true就是这个的关键了，把这个设置为true之后，每次在读取某一个容器的持有对象之后，这个持有的对象将会被放到尾部。

@Override public V get(Object key) {
        /*
         * This method is overridden to eliminate the need for a polymorphic
         * invocation in superclass at the expense of code duplication.
         */
        if (key == null) {
            HashMapEntry<K, V> e = entryForNullKey;
            if (e == null)
                return null;
            if (accessOrder)
                makeTail((LinkedEntry<K, V>) e);
            return e.value;
        } 

        int hash = Collections.secondaryHash(key);
        HashMapEntry<K, V>[] tab = table;
        for (HashMapEntry<K, V> e = tab[hash & (tab.length - 1)];
                e != null; e = e.next) {
            K eKey = e.key;
            if (eKey == key || (e.hash == hash && key.equals(eKey))) {
                if (accessOrder)  //构造函数中传递进来的布尔参数
                    makeTail((LinkedEntry<K, V>) e);
                return e.value;
            }
        }
        return null;
    }

private void makeTail(LinkedEntry<K, V> e) {//将访问的参数移动至链表末端。
        // Unlink e
        e.prv.nxt = e.nxt;
        e.nxt.prv = e.prv;

        // Relink e as tail
        LinkedEntry<K, V> header = this.header;
        LinkedEntry<K, V> oldTail = header.prv;
        e.nxt = header;
        e.prv = oldTail;
        oldTail.nxt = header.prv = e;
        modCount++;
    }

方法中的accessorder就是你在构造函数里面传递进去的，只要这个是true，执行了get方法之后，就会把这个函数移动到链表的表尾，有了以上的基础，LRU似乎变得更加简单了。我们需要做的就是在每次缓存判断之后，如果需要删除图片引用，将链表中的第一个元素删除就可以了，因为最近使用的都会被移动到后面。

/** Caches {@code Bitmap} for {@code key}. The Bitmap is moved to the head of the queue. */
    @Override
    public final boolean put(String key, Bitmap value) {
        if (key == null || value == null) {
            throw new NullPointerException("key == null || value == null");
        }

        synchronized (this) {
            size += sizeOf(key, value);
            Bitmap previous = map.put(key, value);
            if (previous != null) {
                size -= sizeOf(key, previous);
            }
        }

        trimToSize(maxSize);
        return true;
    }

    /**
     * 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.
     */
    private void trimToSize(int maxSize) {
        while (true) {
            String key;
            Bitmap 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<String, Bitmap> toEvict = map.entrySet().iterator().next();
                if (toEvict == null) {
                    break;
                }
                key = toEvict.getKey();
                value = toEvict.getValue();
                map.remove(key);
                size -= sizeOf(key, value);
            }
        }
    }

在每次图片放进去之后，都会使用trimToSize方法进行容器调整，调整到缓存里面的大小小于穿进来的参数，在这里穿进去的自然就是我们设置的缓存大小。

2.FIFOLimitedMemoryCache： 先进先出的一个策略。跟LRU的区别是，他每次都是简单的删除最先加入的元素，就是一个队列的形式，这个就没有上面的那个复杂了，这只需要一个List记录下保存的图片信息，每次删除队列中的第一个就行了：

@Override
    protected Bitmap removeNext() {
        return queue.remove(0);
    }

这个子类在这个方法的实现上就是这么简单的一个操作，删除第一个元素

3.FuzzyKeyMemoryCache：这个是一个key等价删除策略，在构造器中穿一个Comparator参数进来，重写public int compare(T lhs, T rhs);这个方法，这种缓存会把已经缓存的key和将要缓存的key进行自己实现定义的方式进行对比，如果出现了这种等价就删除掉第一个对应的entry。如果没有找到就不用删除。核心代码 ：

@Override
    public boolean put(String key, Bitmap value) {
        // Search equal key and remove this entry
        synchronized (cache) {
            String keyToRemove = null;
            for (String cacheKey : cache.keys()) {
                if (keyComparator.compare(key, cacheKey) == 0) {
                    keyToRemove = cacheKey;
                    break;
                }
            }
            if (keyToRemove != null) {
                cache.remove(keyToRemove);
            }
        }
        return cache.put(key, value);
    }

4.LargestLimitedMemoryCache：这个缓存策略是在放入缓存前检测已经缓存的总容量，如果超过了这个值就删除掉占用内存最大的元素，这个就像是以前做的java基础体，在一个数组里面找出最大值一样：

@Override
    protected Bitmap removeNext() {
        Integer maxSize = null;
        Bitmap largestValue = null;
        Set<Entry<Bitmap, Integer>> entries = valueSizes.entrySet();
        synchronized (valueSizes) {
            for (Entry<Bitmap, Integer> entry : entries) {
                if (largestValue == null) {
                    largestValue = entry.getKey();
                    maxSize = entry.getValue();
                } else {
                    Integer size = entry.getValue();
                    if (size > maxSize) {
                        maxSize = size;
                        largestValue = entry.getKey();
                    }
                }
            }
        }
        valueSizes.remove(largestValue);
        return largestValue;
    }

首先默认把第一个当作最小的，然后循环跟后面的进行比较，出现更大的就进行赋值，这样循环结束之后就可以得到占用内存最大的那个引用了。

5.LimitedAgeMemoryCache ： 这个是一个时间限制的缓存策略，每次在引用一个对象到内存的时候，使用一个HashMap记录下来key和它存进去的时间，然后在访问缓存中的某张图片的时候，跟当前时间进行一个比较，如果这个两个时间的差值大于设置的缓存时间，就会把图片引用从缓存中删掉。

@Override
    public boolean put(String key, Bitmap value) {
        boolean putSuccesfully = cache.put(key, value);
        if (putSuccesfully) {
            loadingDates.put(key, System.currentTimeMillis());
        }
        return putSuccesfully;
    }

    @Override
    public Bitmap get(String key) {
        Long loadingDate = loadingDates.get(key);
        if (loadingDate != null && System.currentTimeMillis() - loadingDate > maxAge) {
            cache.remove(key);
            loadingDates.remove(key);
        }

        return cache.get(key);
    }

第一个方法在保存的时候，同时保存当前时间。第二个方法在取出的时候，进行时间的检测。

6. UsingFreqLimitedMemoryCache ： 在缓存超过限制之后，根据使用频率最少的引用进行优先的删除，这个是在保存引用的时候保存的是key和使用次数，放进去的时候记录次数为0，每次get调用次数加1，然后在调用removeNext的时候，找出使用次数最少的引用，跟上面找出占用内存最大的引用的方式基本相同。

@Override
    protected Bitmap removeNext() {
        Integer minUsageCount = null;
        Bitmap leastUsedValue = null;
        Set<Entry<Bitmap, Integer>> entries = usingCounts.entrySet();
        synchronized (usingCounts) {
            for (Entry<Bitmap, Integer> entry : entries) {
                if (leastUsedValue == null) {
                    leastUsedValue = entry.getKey();
                    minUsageCount = entry.getValue();
                } else {
                    Integer lastValueUsage = entry.getValue();
                    if (lastValueUsage < minUsageCount) {
                        minUsageCount = lastValueUsage;
                        leastUsedValue = entry.getKey();
                    }
                }
            }
        }
        usingCounts.remove(leastUsedValue);
        return leastUsedValue;
    }

以上是对几种内存缓存方式的总结，之后将会推出磁盘缓存策略，算法核心是类似的，就是多了一个I/O操作。