现在的位置: 首页 > 综合 > 正文

【Java&Android开源库代码剖析】のAndroid-Universal-Image-Loader-part1

2017年11月02日 ⁄ 综合 ⁄ 共 17085字 ⁄ 字号 小 中 大 ⁄ 评论关闭
分类： ASCE1885的Android学习研究2013-08-25
19:01 1190人阅读 评论(0) 收藏 举报

    做Android app开发的同学应该都听说过或者用过nostra13的Android-Universal-Image-Loader开源库，它在图片异步加载、缓存和显示等方面提供了强大灵活的框架。之前介绍过的android-smart-image-view开源库跟它比起来，真是小巫见大巫了，不仅在功能上，而且在代码量上都差别很大。当然我们在选取开源库的时候并不是功能越强大越好，一切都要看具体需求，只选取能够满足需求的就行，Less Is More。

    Android-Universal-Image-Loader可以到https://github.com/nostra13/Android-Universal-Image-Loader上面获取，至于它的使用方法，作者写了3篇博文进行了详细的介绍

（http://www.intexsoft.com/blog/item/68-universal-image-loader-part-1.html），本文就不再赘述了。首先，让我们先瞄一下Image-Loader库的整体包结构：


    可以看到，包结构基本上也是根据功能来命名的，即图片异步加载、缓存和显示以及一些工具类。这篇文章我们先来分析下图片的内存缓存实现原理，内存缓存在介绍smart-image-view开源库时已经接触过，只不过当时的实现很简单，Bitmap以软引用的方式直接放到CurrentHashMap中，没有任何过期删除策略，也没有限制缓存大小等等。Image-Loader库将这些都考虑在内了，是一个较完整的内存缓存实现，使用者可以根据需要选择已经实现的策略，也可以定制自己项目中需要的策略。ImageLoader库大量使用了面向接口设计，面向接口设计方式专注于对象所提供的服务或模块的职责，而不是它们的实现。它明确地将规范视图从实现视图中剥离出来。内存缓存实现代码在memory和memory.impl这两个包中，前者就是规范视图，后者是实现视图。memory包中有MemoryCacheAware接口和BaseMemoryCache和LimitedMemoryCache两个抽象类，加上memory.impl包中的WeakMemoryCache类，类图如下所示：

    MemoryCacheAware接口以泛型方式定义了实现缓存所需的基础规约，包括写缓存、读缓存、删除缓存和遍历缓存等，如下所示：

  1. /** 
  2.  * Interface for memory cache 
  3.  * 
  4.  * @author Sergey Tarasevich (nostra13[at]gmail[dot]com) 
  5.  * @since 1.0.0 
  6.  */  
  7. public interface MemoryCacheAware<K, V> {  
  8.     /** 
  9.      * Puts value into cache by key 
  10.      * 
  11.      * @return <b>true</b> - if value was put into cache successfully, <b>false</b> - if value was <b>not</b> put into 
  12.      *         cache 
  13.      */  
  14.     boolean put(K key, V value);  
  15.   
  16.     /** Returns value by key. If there is no value for key then null will be returned. */  
  17.     V get(K key);  
  18.   
  19.     /** Removes item by key */  
  20.     void remove(K key);  
  21.   
  22.     /** Returns all keys of cache */  
  23.     Collection<K> keys();  
  24.   
  25.     /** Remove all items from cache */  
  26.     void clear();  
  27. }  

接口定义好，一般都会提供一个接口的基础实现类，这个类需要实现接口中的方法，并提供子类可以公用的操作，由smart-image-view这篇文章我们知道，在Android中图片最终表现为Bitmap的实例，为了Bitmap及时释放，一般内存缓存中不会直接存放Bitmap的强引用，而是使用弱引用SoftReference，但在Java中，还存在另外两种引用类型，即WeakReference和PhantomReference，考虑到通用性，在内存缓存的抽象基类BaseMemoryCache中将使用上面三种引用的父类Reference。内存缓存依然使用哈希表来实现。代码如下：

  1. /** Stores not strong references to objects */  
  2. private final Map<K, Reference<V>> softMap = Collections.synchronizedMap(new HashMap<K, Reference<V>>());  

回顾我们在smart-image-view库中的哈希表定义：

  1. private ConcurrentHashMap<String, SoftReference<Bitmap>> memoryCache = new ConcurrentHashMap<String, SoftReference<Bitmap>>();;  

可以发现最大的区别是一个使用Collections.synchronizedMap，一个使用ConcurrentHashMap，两者都是实现线程安全的HashMap，区别在哪里呢？感兴趣的可以自己看JDK源码，或者百度之，这里只给出结论：ConcurrentHashMap的读写性能要比Collections.synchronizedMap高，尽量使用前者。下面就看下BaseMemoryCache的代码吧：

  1. /** 
  2.  * Base memory cache. Implements common functionality for memory cache. Provides object references ( 
  3.  * {@linkplain Reference not strong}) storing. 
  4.  * 
  5.  * @author Sergey Tarasevich (nostra13[at]gmail[dot]com) 
  6.  * @since 1.0.0 
  7.  */  
  8. public abstract class BaseMemoryCache<K, V> implements MemoryCacheAware<K, V> {  
  9.   
  10.     /** Stores not strong references to objects */  
  11.     private final Map<K, Reference<V>> softMap = Collections.synchronizedMap(new HashMap<K, Reference<V>>());  
  12.   
  13.     @Override  
  14.     public V get(K key) {  
  15.         V result = null;  
  16.         Reference<V> reference = softMap.get(key);  
  17.         if (reference != null) {  
  18.             result = reference.get();  
  19.         }  
  20.         return result;  
  21.     }  
  22.   
  23.     @Override  
  24.     public boolean put(K key, V value) {  
  25.         softMap.put(key, createReference(value));  
  26.         return true;  
  27.     }  
  28.   
  29.     @Override  
  30.     public void remove(K key) {  
  31.         softMap.remove(key);  
  32.     }  
  33.   
  34.     @Override  
  35.     public Collection<K> keys() {  
  36.         synchronized (softMap) {  
  37.             return new HashSet<K>(softMap.keySet());  
  38.         }  
  39.     }  
  40.   
  41.     @Override  
  42.     public void clear() {  
  43.         softMap.clear();  
  44.     }  
  45.   
  46.     /** Creates {@linkplain Reference not strong} reference of value */  
  47.     protected abstract Reference<V> createReference(V value);  
  48. }  

基本上就是HashMap的操作，由于具体Reference的实现需要看到底用的哪种引用，因此，这里将createReference定义成抽象函数，让BaseMemoryCache的子类去定制实现。

BaseMemoryCache的一个最简单的子类实现是WeakMemoryCache类，它仅仅是实现了createReference抽象方法，返回Bitmap对象的弱引用：

  1. public class WeakMemoryCache extends BaseMemoryCache<String, Bitmap> {  
  2.     @Override  
  3.     protected Reference<Bitmap> createReference(Bitmap value) {  
  4.         return new WeakReference<Bitmap>(value);  
  5.     }  
  6. }  

BaseMemoryCache的另一个子类是LimitedMemoryCache，它也是抽象类，定义了实现内存缓存限制策略的公共操作。既然要限制缓存大小，那么首先需要定义默认的缓存最大值，同时需要维护一个表示当前缓存已占用大小的变量，考虑到多线程问题，这个变量值得增减必须保证是原子的，因此，该变量类型选用AtomicInteger。如下所示：

  1. private static final int MAX_NORMAL_CACHE_SIZE_IN_MB = 16;  
  2. private static final int MAX_NORMAL_CACHE_SIZE = MAX_NORMAL_CACHE_SIZE_IN_MB * 1024 * 1024;  
  3.   
  4. private final int sizeLimit;  
  5.   
  6. private final AtomicInteger cacheSize;  

同时，为了计算已添加到缓存中的数据大小，需要新增一个指向强引用的数据结构来进行记录，而不是使用BaseMemoryCache中的softMap哈希表，因为softMap中存放的是Reference类，里面的数据可能会被GC回收，用来统计已占用大小时不准确。指向数据强引用的数据结构选用LinkedList，定义如下，同样采用线程安全版本。

  1. /** 
  2.  * Contains strong references to stored objects. Each next object is added last. If hard cache size will exceed 
  3.  * limit then first object is deleted (but it continue exist at {@link #softMap} and can be collected by GC at any 
  4.  * time) 
  5.  */  
  6. private final List<V> hardCache = Collections.synchronizedList(new LinkedList<V>());  

往LimitedMemoryCache中添加数据时，首先要计算出当前这个数据的大小（getSize()），然后加上已占用缓存大小后，跟缓存最大值相比较，超过缓存最大值时，就需要根据缓存清理策略（removeNext()）删除以前的一些数据，直到添加数据后，总占用大小在最大值之内为止。上面提到的getSize()函数和removeNext函数需要子类定制，所以定义成了抽象函数。这是典型的模板方法模式的应用，模板方法模式定义一个操作中算法的步骤，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。下面的put函数中实现的就是算法的步骤，而getSize()和removeNext()函数则是子类可重定义的特定步骤。相关代码如下所示：

  1. @Override  
  2. public boolean put(K key, V value) {  
  3.     boolean putSuccessfully = false;  
  4.     // Try to add value to hard cache  
  5.     int valueSize = getSize(value);  
  6.     int sizeLimit = getSizeLimit();  
  7.     int curCacheSize = cacheSize.get();  
  8.     if (valueSize < sizeLimit) {  
  9.         while (curCacheSize + valueSize > sizeLimit) {  
  10.             V removedValue = removeNext();  
  11.             if (hardCache.remove(removedValue)) {  
  12.                 curCacheSize = cacheSize.addAndGet(-getSize(removedValue));  
  13.             }  
  14.         }  
  15.         hardCache.add(value);  
  16.         cacheSize.addAndGet(valueSize);  
  17.   
  18.         putSuccessfully = true;  
  19.     }  
  20.     // Add value to soft cache  
  21.     super.put(key, value);  
  22.     return putSuccessfully;  
  23. }  
  24.   
  25. protected abstract int getSize(V value);  
  26.   
  27. protected abstract V removeNext();  

    接下来就介绍LimitedMemoryCache的几个子类的具体实现，它们分别是FIFOLimitedMemoryCache、LargestLimitedMemoryCache、LRULimitedMemoryCache和UsingFreqLimitedMemoryCache。类图如下：

【FIFOLimitedMemoryCache类】

FIFO算法意思是在缓存超过最大值时，缓存清理策略是将最老的数据清理掉，因此使用队列这样的数据结构就可以很好的实现，在Java中，LinkedList类可以实现这样的功能。

  1. private final List<Bitmap> queue = Collections.synchronizedList(new LinkedList<Bitmap>());  

而父类LimitedMemoryCache中也定义了类似的数据结构hardCache专门用于计算缓存的数据大小，只不过它是私有的，子类不能使用。但这样就会造成在FIFOLimitedMemoryCache类中存在两个类似的数据结构，内存占用会变大，事实上，FIFOLimitedMemoryCache中的queue完全可以直接使用父类的hardCache，作者之所以没有直接使用，应该是考虑到代码整体类层次结构清晰的问题，毕竟hardCache专门是用于计算缓存大小的，子类实现方式很多种，很多子类并不需要直接使用hardCache，所以单独一个FIFOLimitedMemoryCache以空间来换取代码结构的清晰也是可以理解的。写缓存和清缓存代码如下：

  1. @Override  
  2. public boolean put(String key, Bitmap value) {  
  3.     if (super.put(key, value)) {  
  4.         queue.add(value);  
  5.         return true;  
  6.     } else {  
  7.         return false;  
  8.     }  
  9. }  
  10.   
  11. @Override  
  12. public void remove(String key) {  
  13.     Bitmap value = super.get(key);  
  14.     if (value != null) {  
  15.         queue.remove(value);  
  16.     }  
  17.     super.remove(key);  
  18. }  
  19.   
  20. @Override  
  21. public void clear() {  
  22.     queue.clear();  
  23.     super.clear();  
  24. }  

前面说到的父类总共有3个抽象函数，需要子类予以实现，代码如下：

  1. @Override  
  2. protected int getSize(Bitmap value) {  
  3.     return value.getRowBytes() * value.getHeight();  
  4. }  
  5.   
  6. @Override  
  7. protected Bitmap removeNext() {  
  8.     return queue.remove(0);  
  9. }  
  10.   
  11. @Override  
  12. protected Reference<Bitmap> createReference(Bitmap value) {  
  13.     return new WeakReference<Bitmap>(value);  
  14. }  

getSize函数中可以看到计算Bitmap占用字节大小的典型方法。removeNext函数中移除队列queue头部的数据，这个数据是最先进入队列的数据。而Bitmap的Reference使用的是弱引用，它和软引用的区别是，弱引用对象拥有更短暂的生命周期，在垃圾回收器线程扫描它所管辖的内存区域过程中，只要发现只具有弱引用的对象，那么不管当前内存空间是否足够，都会回收弱引用对象占用的内存。这样可以更好的防止出现OutOfMemoryError错误。

【LargestLimitedMemoryCache类】

当缓存超出最大值限制时，清理策略是将占用空间最大的数据清理掉。因此，需要一个维护Bitmap对象到它占用大小的映射，这里使用的还是HashMap：

  1. /** 
  2.  * Contains strong references to stored objects (keys) and last object usage date (in milliseconds). If hard cache 
  3.  * size will exceed limit then object with the least frequently usage is deleted (but it continue exist at 
  4.  * {@link #softMap} and can be collected by GC at any time) 
  5.  */  
  6. private final Map<Bitmap, Integer> valueSizes = Collections.synchronizedMap(new HashMap<Bitmap, Integer>());  

同理，关键代码还是在父类几个抽象函数的实现，其中getSize()和createReference()函数实现和FIFOLimitedMemoryCache类一样，removeNext函数实现如下：

  1. @Override  
  2. protected Bitmap removeNext() {  
  3.     Integer maxSize = null;  
  4.     Bitmap largestValue = null;  
  5.     Set<Entry<Bitmap, Integer>> entries = valueSizes.entrySet();  
  6.     synchronized (valueSizes) {  
  7.         for (Entry<Bitmap, Integer> entry : entries) {  
  8.             if (largestValue == null) {  
  9.                 largestValue = entry.getKey();  
  10.                 maxSize = entry.getValue();  
  11.             } else {  
  12.                 Integer size = entry.getValue();  
  13.                 if (size > maxSize) {  
  14.                     maxSize = size;  
  15.                     largestValue = entry.getKey();  
  16.                 }  
  17.             }  
  18.         }  
  19.     }  
  20.     valueSizes.remove(largestValue);  
  21.     return largestValue;  
  22. }  

基本原理是遍历valueSizes这个哈希表，比较并得到占用空间最大的Bitmap对象，然后删除它即可。这里要注意的一点是遍历时要加入synchronized同步机制。

【LRULimitedMemoryCache类】

LRU即Least Recently Used，缓存清理策略是将最近最少使用的Bitmap对象删除掉。按Java中刚好有这样一个数据结构可以实现这个策略，它就是LinkedHashMap类。

  1. private static final int INITIAL_CAPACITY = 10;  
  2. private static final float LOAD_FACTOR = 1.1f;  
  3.   
  4. /** Cache providing Least-Recently-Used logic */  
  5. private final Map<String, Bitmap> lruCache = Collections.synchronizedMap(new LinkedHashMap<String, Bitmap>(INITIAL_CAPACITY, LOAD_FACTOR, true));  

LinkedHashMap是HashMap的子类，注意它的构造函数第三个参数accessOrder，它定义了LinkedHashMap的排序模式，accessOrder为true时，表示LinkedHashMap中数据排序按照访问的顺序，当为false时，表示数据排序按照数据插入的顺序。而我们要实现LRU，就需要把accessOrder设置为true，同时，在读缓存时不能像FIFOLimitedMemoryCache类和LargestLimitedMemoryCache类一样使用父类BaseMemoryCache的get方法，而是应该重写该方法如下所示：

  1. @Override  
  2. public Bitmap get(String key) {  
  3.     lruCache.get(key); // call "get" for LRU logic  
  4.     return super.get(key);  
  5. }  

当accessOrder设置为true时，LinkedHashMap就维护了记录的访问顺序，这时使用Iterator 遍历LinkedHashMap时，先得到的记录肯定就是最近最不常使用的那个记录了，LRU算法水到渠成：

  1. @Override  
  2. protected Bitmap removeNext() {  
  3.     Bitmap mostLongUsedValue = null;  
  4.     synchronized (lruCache) {  
  5.         Iterator<Entry<String, Bitmap>> it = lruCache.entrySet().iterator();  
  6.         if (it.hasNext()) {  
  7.             Entry<String, Bitmap> entry = it.next();  
  8.             mostLongUsedValue = entry.getValue();  
  9.             it.remove();  
  10.         }  
  11.     }  
  12.     return mostLongUsedValue;  
  13. }  

【UsingFreqLimitedMemoryCache类】

和LargestLimitedMemoryCache类实现类似，只不过一个是将占用空间最大的记录剔除，一个是将访问次数最少的记录剔除，所用数据结构自然类似：

  1. /** 
  2.  * Contains strong references to stored objects (keys) and last object usage date (in milliseconds). If hard cache 
  3.  * size will exceed limit then object with the least frequently usage is deleted (but it continue exist at 
  4.  * {@link #softMap} and can be collected by GC at any time) 
  5.  */  
  6. private final Map<Bitmap, Integer> usingCounts = Collections.synchronizedMap(new HashMap<Bitmap, Integer>());  

因为要记录访问次数，所以需要重写父类的get方法，每访问一次，就增加计数值：

  1. @Override  
  2. public Bitmap get(String key) {  
  3.     Bitmap value = super.get(key);  
  4.     // Increment usage count for value if value is contained in hardCahe  
  5.     if (value != null) {  
  6.         Integer usageCount = usingCounts.get(value);  
  7.         if (usageCount != null) {  
  8.             usingCounts.put(value, usageCount + 1);  
  9.         }  
  10.     }  
  11.     return value;  
  12. }  

removeNext函数实现原理是遍历usingCounts哈希表中的记录，比较它们的访问次数，并选取访问次数最少的一个删除之，代码如下所示，同LargestLimitedMemoryCache类，要注意使用synchronized关键字同步保护。

  1. @Override  
  2. protected Bitmap removeNext() {  
  3.     Integer minUsageCount = null;  
  4.     Bitmap leastUsedValue = null;  
  5.     Set<Entry<Bitmap, Integer>> entries = usingCounts.entrySet();  
  6.     synchronized (usingCounts) {  
  7.         for (Entry<Bitmap, Integer> entry : entries) {  
  8.             if (leastUsedValue == null) {  
  9.                 leastUsedValue = entry.getKey();  
  10.                 minUsageCount = entry.getValue();  
  11.             } else {  
  12.                 Integer lastValueUsage = entry.getValue();  
  13.                 if (lastValueUsage < minUsageCount) {  
  14.                     minUsageCount = lastValueUsage;  
  15.                     leastUsedValue = entry.getKey();  
  16.                 }  
  17.             }  
  18.         }  
  19.     }  
  20.     usingCounts.remove(leastUsedValue);  
  21.     return leastUsedValue;  
  22. }  

最后，在memory.impl包中还有几个类是直接实现MemoryCacheAware接口的，我们先来看下他们的类结构图：

从类图可以看到，FuzzyKeyMemoryCache类和LimitedAgeMemoryCache类都实现了MemoryCacheAware接口，同时聚合了MemoryCacheAware类型的对象。熟悉设计模式的同学应该能够一眼看出这个就是装饰者模式的应用。装饰者（Decorator）模式用于动态地给一个对象添加一些额外的职责，就增加功能而言，Decorator模式相比生成子类更为灵活。在Decorator模式的实现中，为了能够实现和原来使用被装饰对象的代码的无缝结合，装饰者类需要实现与被装饰对象相同的接口，同时在装饰者类中转调被装饰对象的功能，在转调的前后添加新的功能。就我们的代码来说，被装饰对象就是实现了MemoryCacheAware接口的类对象，装饰者对象就是FuzzyKeyMemoryCache类和LimitedAgeMemoryCache类的对象。更详细的关于Decorator模式的了解查阅设计模式的书籍。

【FuzzyKeyMemoryCache类】

在之前实现内存缓存的映射时，是一个key对应一个value，而这个装饰者类提供的额外功能是：允许多个key对应同一个value，后面插入的key-value对会覆盖以前存在的key-value对。这个类主要用于Image-Loader库内部使用。在FuzzyKeyMemoryCache类的实现中，使用Comparator类实现多个key是否相等的判断，核心代码在put函数中：

  1. /** 
  2.  * Decorator for {@link MemoryCacheAware}. Provides special feature for cache: some different keys are considered as 
  3.  * equals (using {@link Comparator comparator}). And when you try to put some value into cache by key so entries with 
  4.  * "equals" keys will be removed from cache before.<br /> 
  5.  * <b>NOTE:</b> Used for internal needs. Normally you don't need to use this class. 
  6.  * 
  7.  * @author Sergey Tarasevich (nostra13[at]gmail[dot]com) 
  8.  * @since 1.0.0 
  9.  */  
  10. public class FuzzyKeyMemoryCache<K, V> implements MemoryCacheAware<K, V> {  
  11.   
  12.     private final MemoryCacheAware<K, V> cache;  
  13.     private final Comparator<K> keyComparator;  
  14.   
  15.     public FuzzyKeyMemoryCache(MemoryCacheAware<K, V> cache, Comparator<K> keyComparator) {  
  16.         this.cache = cache;  
  17.         this.keyComparator = keyComparator;  
  18.     }  
  19.   
  20.     @Override  
  21.     public boolean put(K key, V value) {  
  22.         // Search equal key and remove this entry  
  23.         synchronized (cache) {  
  24.             K keyToRemove = null;  
  25.             for (K cacheKey : cache.keys()) {  
  26.                 if (keyComparator.compare(key, cacheKey) == 0) {  
  27.                     keyToRemove = cacheKey;  
  28.                     break;  
  29.                 }  
  30.             }  
  31.             if (keyToRemove != null) {  
  32.                 cache.remove(keyToRemove);  
  33.             }  
  34.         }  
  35.         return cache.put(key, value);  
  36.     }  
  37.   
  38.     @Override  
  39.     public V get(K key) {  
  40.         return cache.get(key);  
  41.     }  
  42.   
  43.     @Override  
  44.     public void remove(K key) {  
  45.         cache.remove(key);  
  46.     }  
  47.   
  48.     @Override  
  49.     public void clear() {  
  50.         cache.clear();  
  51.     }  
  52.   
  53.     @Override  
  54.     public Collection<K> keys() {  
  55.         return cache.keys();  
  56.     }  
  57. }  

【LimitedAgeMemoryCache类】

在前面介绍过的MemoryCacheAware接口实现类中，有时可能需要添加这样一个额外的功能：当缓存的对象存在超过一定时间时，将其清理掉，LimitedAgeMemoryCache这个装饰者类就是实现这样一个功能。首先，实现一个缓存对象key到已存活时间的映射表，在获取缓存对象时，判断该对象是否超过最大存活时间，如果是则将其移除。代码如下所示：

  1. /** 
  2.  * Decorator for {@link MemoryCacheAware}. Provides special feature for cache: if some cached object age exceeds defined 
  3.  * value then this object will be removed from cache. 
  4.  * 
  5.  * @author Sergey Tarasevich (nostra13[at]gmail[dot]com) 
  6.  * @see MemoryCacheAware 
  7.  * @since 1.3.1 
  8.  */  
  9. public class LimitedAgeMemoryCache<K, V> implements MemoryCacheAware<K, V> {  
  10.   
  11.     private final MemoryCacheAware<K, V> cache;  
  12.   
  13.     private final long maxAge;  
  14.     private final Map<K, Long> loadingDates = Collections.synchronizedMap(new HashMap<K, Long>());  
  15.   
  16.     /** 
  17.      * @param cache  Wrapped memory cache 
  18.      * @param maxAge Max object age <b>(in seconds)</b>. If object age will exceed this value then it'll be removed from 
  19.      *               cache on next treatment (and therefore be reloaded). 
  20.      */  
  21.     public LimitedAgeMemoryCache(MemoryCacheAware<K, V> cache, long maxAge) {  
  22.         this.cache = cache;  
  23.         this.maxAge = maxAge * 1000; // to milliseconds  
  24.     }  
  25.   
  26.     @Override  
  27.     public boolean put(K key, V value) {  
  28.         boolean putSuccesfully = cache.put(key, value);  
  29.         if (putSuccesfully) {  
  30.             loadingDates.put(key, System.currentTimeMillis());  
  31.         }  
  32.         return putSuccesfully;  
  33.     }  
  34.   
  35.     @Override  
  36.     public V get(K key) {  
  37.         Long loadingDate = loadingDates.get(key);  
  38.         if (loadingDate != null && System.currentTimeMillis() - loadingDate > maxAge) {  
  39.             cache.remove(key);  
  40.             loadingDates.remove(key);  
  41.         }  
  42.   
  43.         return cache.get(key);  
  44.     }  
  45.   
  46.     @Override  
  47.     public void remove(K key) {  
  48.         cache.remove(key);  
  49.         loadingDates.remove(key);  
  50.     }  
  51.   
  52.     @Override  
  53.     public Collection<K> keys() {  
  54.         return cache.keys();  
  55.     }  
  56.   
  57.     @Override  
  58.     public void clear() {  
  59.         cache.clear();  
  60.         loadingDates.clear();  
  61.     }  
  62. }  

——欢迎转载，请注明出处 http://blog.csdn.net/asce1885 ，未经本人同意请勿用于商业用途，谢谢——

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞