Universal-Image-Loader源码分析，及常用的缓存策略

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

        this.trimToSize(this.maxSize);
        return true;
    } else {
        throw new NullPointerException("key == null || value == null");
    }
}

private void trimToSize(int maxSize) {
    while(true) {
        synchronized(this) {
            if(this.size < 0 || this.map.isEmpty() && this.size != 0) {
                throw new IllegalStateException(this.getClass().getName() + ".sizeOf() is reporting inconsistent results!");
            }

            if(this.size > maxSize && !this.map.isEmpty()) {
                Entry toEvict = (Entry)this.map.entrySet().iterator().next();
                if(toEvict != null) {
                    String key = (String)toEvict.getKey();
                    Bitmap value = (Bitmap)toEvict.getValue();
                    this.map.remove(key);
                    this.size -= this.sizeOf(key, value);
                    continue;
                }
            }

            return;
        }
    }
}

这时候我们会有一个以为，为什么遍历一下就可以将使用最少的bitmap缓存给剔除，不会误删到最近使用的bitmap缓存吗？首先，我们要清楚，LruMemoryCache定义的最近使用是指最近用get或put方式操作到的bitmap缓存。其次，之前我们直到LruMemoryCache的get操作其实是通过其内部字段LinkedHashMap.get(...)实现的，当LinkedHashMap的accessOrder==true时，每一次get或put操作都会将所操作项（图中第3项）移动到链表的尾部(见下图,链表头被认为是最少使用的，链表尾被认为是最常使用的。)，每一次操作到的项我们都认为它是最近使用过的，当内存不够的时候被剔除的优先级最低。需要注意的是一开始的LinkedHashMap链表是按插入的顺序构成的，也就是第一个插入的项就在链表头，最后一个插入的就在链表尾。假设只要剔除图中的1,2项就能让LruMemoryCache小于原先限定的大小，那么我们只要从链表头遍历下去（从1→最后一项）那么就可以剔除使用最少的项了。

至此，我们就知道了LruMemoryCache缓存的整个原理，包括他怎么put、get、剔除一个元素的的策略。接下去，我们要开始分析默认的磁盘缓存策略了。

UIL中的磁盘缓存策略

幸好UIL提供了几种常见的磁盘缓存策略，你也可以自己去扩展，可以根据他提供的几种缓存策略做进一步的缓存值的限制，

• UsingFreqLimitedMemoryCache（如果缓存的图片总量超过限定值，先删除使用频率最小的bitmap）
• LRULimitedMemoryCache（这个也是使用的lru算法，和LruMemoryCache不同的是，他缓存的是bitmap的弱引用）
• FIFOLimitedMemoryCache（先进先出的缓存策略，当超过设定值，先删除最先加入缓存的bitmap）
• LargestLimitedMemoryCache(当超过缓存限定值，先删除最大的bitmap对象)
• LimitedAgeMemoryCache（当 bitmap加入缓存中的时间超过我们设定的值，将其删除）

在UIL中有着比较完整的存储策略，根据预先指定的空间大小，使用频率(生命周期)，文件个数的约束条件，都有着对应的实现策略。最基础的接口DiscCacheAware和抽象类BaseDiscCache

接下来就给大家分析分析硬盘缓存的策略，这个框架也提供了几种常见的缓存策略，当然如果你觉得都不符合你的要求，你也可以自己去扩展

• FileCountLimitedDiscCache（可以设定缓存图片的个数，当超过设定值，删除掉最先加入到硬盘的文件）
• LimitedAgeDiscCache（设定文件存活的最长时间，当超过这个值，就删除该文件）
• TotalSizeLimitedDiscCache（设定缓存bitmap的最大值，当超过这个值，删除最先加入到硬盘的文件）
• UnlimitedDiscCache（这个缓存类没有任何的限制）

下面我们就来分析分析TotalSizeLimitedDiscCache的源码实现

[java]  view plain  copy

 

1. /******************************************************************************* 
2.  * Copyright 2011-2013 Sergey Tarasevich 
3.  * 
4.  * Licensed under the Apache License, Version 2.0 (the "License"); 
5.  * you may not use this file except in compliance with the License. 
6.  * You may obtain a copy of the License at 
7.  * 
8.  * http://www.apache.org/licenses/LICENSE-2.0 
9.  * 
10.  * Unless required by applicable law or agreed to in writing, software 
11.  * distributed under the License is distributed on an "AS IS" BASIS, 
12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
13.  * See the License for the specific language governing permissions and 
14.  * limitations under the License. 
15.  *******************************************************************************/  
16. package com.nostra13.universalimageloader.cache.disc.impl;  
17.   
18. import com.nostra13.universalimageloader.cache.disc.LimitedDiscCache;  
19. import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator;  
20. import com.nostra13.universalimageloader.core.DefaultConfigurationFactory;  
21. import com.nostra13.universalimageloader.utils.L;  
22.   
23. import java.io.File;  
24.   
25. /** 
26.  * Disc cache limited by total cache size. If cache size exceeds specified limit then file with the most oldest last 
27.  * usage date will be deleted. 
28.  * 
29.  * @author Sergey Tarasevich (nostra13[at]gmail[dot]com) 
30.  * @see LimitedDiscCache 
31.  * @since 1.0.0 
32.  */  
33. public class TotalSizeLimitedDiscCache extends LimitedDiscCache {  
34.   
35.     private static final int MIN_NORMAL_CACHE_SIZE_IN_MB = 2;  
36.     private static final int MIN_NORMAL_CACHE_SIZE = MIN_NORMAL_CACHE_SIZE_IN_MB * 1024 * 1024;  
37.   
38.     /** 
39.      * @param cacheDir     Directory for file caching. Important: Specify separate folder for cached files. It's 
40.      *                     needed for right cache limit work. 
41.      * @param maxCacheSize Maximum cache directory size (in bytes). If cache size exceeds this limit then file with the 
42.      *                     most oldest last usage date will be deleted. 
43.      */  
44.     public TotalSizeLimitedDiscCache(File cacheDir, int maxCacheSize) {  
45.         this(cacheDir, DefaultConfigurationFactory.createFileNameGenerator(), maxCacheSize);  
46.     }  
47.   
48.     /** 
49.      * @param cacheDir          Directory for file caching. Important: Specify separate folder for cached files. It's 
50.      *                          needed for right cache limit work. 
51.      * @param fileNameGenerator Name generator for cached files 
52.      * @param maxCacheSize      Maximum cache directory size (in bytes). If cache size exceeds this limit then file with the 
53.      *                          most oldest last usage date will be deleted. 
54.      */  
55.     public TotalSizeLimitedDiscCache(File cacheDir, FileNameGenerator fileNameGenerator, int maxCacheSize) {  
56.         super(cacheDir, fileNameGenerator, maxCacheSize);  
57.         if (maxCacheSize  sizeLimit) {  
58.             int freedSize = removeNext();  
59.             if (freedSize == INVALID_SIZE) break; // cache is empty (have nothing to delete)  
60.             curCacheSize = cacheSize.addAndGet(-freedSize);  
61.         }  
62.         cacheSize.addAndGet(valueSize);  
63.   
64.         Long currentTime = System.currentTimeMillis();  
65.         file.setLastModified(currentTime);  
66.         lastUsageDates.put(file, currentTime);  
67.     }  
68.   
69.     /** 
70.      * 根据key生成文件 
71.      */  
72.     @Override  
73.     public File get(String key) {  
74.         File file = super.get(key);  
75.   
76.         Long currentTime = System.currentTimeMillis();  
77.         file.setLastModified(currentTime);  
78.         lastUsageDates.put(file, currentTime);  
79.   
80.         return file;  
81.     }  
82.   
83.     /** 
84.      * 硬盘缓存的清理 
85.      */  
86.     @Override  
87.     public void clear() {  
88.         lastUsageDates.clear();  
89.         cacheSize.set(0);  
90.         super.clear();  
91.     }  
92.   
93.       
94.     /** 
95.      * 获取最早加入的缓存文件，并将其删除 
96.      */  
97.     private int removeNext() {  
98.         if (lastUsageDates.isEmpty()) {  
99.             return INVALID_SIZE;  
100.         }  
101.         Long oldestUsage = null;  
102.         File mostLongUsedFile = null;  
103.           
104.         Set entries = lastUsageDates.entrySet();  
105.         synchronized (lastUsageDates) {  
106.             for (Entry entry : entries) {  
107.                 if (mostLongUsedFile == null) {  
108.                     mostLongUsedFile = entry.getKey();  
109.                     oldestUsage = entry.getValue();  
110.                 } else {  
111.                     Long lastValueUsage = entry.getValue();  
112.                     if (lastValueUsage