[关闭]
@xujun94 2016-07-15T03:23:37.000000Z 字数 18301 阅读 1941

带你了解Android常见的内存缓存算法

本片博客主要简介以下两个问题

  1. 介绍一下常见的内存缓存算法
  2. 怎样实现这些算法

大家应该对ImageLoader这个框架都不陌生吧，一个很强大的图片加载框架，虽然作者去年的时候已经停止维护了，但里面的许多东西还是值得我们去学习的。本篇博客讲解的内存缓存算法正是基于ImageLoader的实现基础之上的

常见的几种缓存算法

也就是当内存缓存达到设定的最大值时将内存缓存中近期最少使用的对象移除，有效的避免了OOM的出现。

对每个缓存对象计算他们被使用的频率。把最不常用的缓存对象换走。

这是一个低负载的算法，并且对缓存对象的管理要求不高。通过一个队列去跟踪所有的缓存对象，最近最常用的缓存对象放在后面，而更早的缓存对象放在前面，当缓存容量满时，排在前面的缓存对象会被踢走，然后把新的缓存对象加进去。

通过绝对的时间周期去失效那些缓存对象。对于新增的对象，保存特定的时间。

超过指定缓存的话，每次移除栈最大内存的缓存的对象

下面我们一起来看一下ImageLoader是怎样实现这些算法的

首先我们一起先来看一下类UML图

源码分析

  1. public abstract class BaseMemoryCache implements MemoryCache {
  3.     /** Stores not strong references to objects */
  4.     private final Map<String, Reference<Bitmap>> softMap = Collections.synchronizedMap(new HashMap<String, Reference<Bitmap>>());
  6.     @Override
  7.     public Bitmap get(String key) {
  8.         Bitmap result = null;
  9.         Reference<Bitmap> reference = softMap.get(key);
  10.         if (reference != null) {
  11.             result = reference.get();
  12.         }
  13.         return result;
  14.     }
  16.     @Override
  17.     public boolean put(String key, Bitmap value) {
  18.         softMap.put(key, createReference(value));
  19.         return true;
  20.     }
  22.     @Override
  23.     public Bitmap remove(String key) {
  24.         Reference<Bitmap> bmpRef = softMap.remove(key);
  25.         return bmpRef == null ? null : bmpRef.get();
  26.     }
  28.     @Override
  29.     public Collection<String> keys() {
  30.         synchronized (softMap) {
  31.             return new HashSet<String>(softMap.keySet());
  32.         }
  33.     }
  35.     @Override
  36.     public void clear() {
  37.         softMap.clear();
  38.     }
  40.     /** Creates {@linkplain Reference not strong} reference of value */
  41.     protected abstract Reference<Bitmap> createReference(Bitmap value);
  42. }

其实就是保存着一份弱引用而已，而它的父类Memory只是定义了几个接口方法，统一标准而已

  1. public abstract class LimitedMemoryCache extends BaseMemoryCache {
  3.     private static final int MAX_NORMAL_CACHE_SIZE_IN_MB = 16;
  4.     private static final int MAX_NORMAL_CACHE_SIZE = MAX_NORMAL_CACHE_SIZE_IN_MB * 1024 * 1024;
  6.     private final int sizeLimit;
  8.     private final AtomicInteger cacheSize;
  10.     /**
  11.      * Contains strong references to stored objects. Each next object is added last. If hard cache size will exceed
  12.      * limit then first object is deleted (but it continue exist at {@link #softMap} and can be collected by GC at any
  13.      * time)
  14.      */
  15.     private final List<Bitmap> hardCache = Collections.synchronizedList(
  16.                                                          new LinkedList<Bitmap>());
  18.     /** @param sizeLimit Maximum size for cache (in bytes) */
  19.     public LimitedMemoryCache(int sizeLimit) {
  20.         this.sizeLimit = sizeLimit;
  21.         cacheSize = new AtomicInteger();
  22.         if (sizeLimit > MAX_NORMAL_CACHE_SIZE) {
  23.             L.w("You set too large memory cache size (more than %1$d Mb)", 
  24.                                                          MAX_NORMAL_CACHE_SIZE_IN_MB);
  25.         }
  26.     }
  28.     @Override
  29.     public boolean put(String key, Bitmap value) {
  30.         boolean putSuccessfully = false;
  31.         // Try to add value to hard cache
  32.         int valueSize = getSize(value);
  33.         int sizeLimit = getSizeLimit();
  34.         int curCacheSize = cacheSize.get();
  35.         if (valueSize < sizeLimit) {
  36.             while (curCacheSize + valueSize > sizeLimit) {
  37.                 Bitmap removedValue = removeNext();
  38.                 if (hardCache.remove(removedValue)) {
  39.                     curCacheSize = cacheSize.addAndGet(-getSize(removedValue));
  40.                 }
  41.             }
  42.             hardCache.add(value);
  43.             cacheSize.addAndGet(valueSize);
  45.             putSuccessfully = true;
  46.         }
  47.         // Add value to soft cache
  48.         super.put(key, value);
  49.         return putSuccessfully;
  50.     }
  52.     @Override
  53.     public Bitmap remove(String key) {
  54.         Bitmap value = super.get(key);
  55.         if (value != null) {
  56.             if (hardCache.remove(value)) {
  57.                 cacheSize.addAndGet(-getSize(value));
  58.             }
  59.         }
  60.         return super.remove(key);
  61.     }
  63.     @Override
  64.     public void clear() {
  65.         hardCache.clear();
  66.         cacheSize.set(0);
  67.         super.clear();
  68.     }
  70.     protected int getSizeLimit() {
  71.         return sizeLimit;
  72.     }
  74.     protected abstract int getSize(Bitmap value);
  76.     protected abstract Bitmap removeNext();
  77. }

LimitedMemoryCache所做的工作可以分为以下几步

注意事项

结合BaseMemoryCache和LimitedMemoryCache，我们可以知道LimitedMemoryCache的子类，至少可以访问两份Bitmap 的缓存，一份是BaseMemoryCache所拥有的softMap ，是弱引用；一份是LimitedMemoryCachehar所拥有的hardCache 集合

  1. //父类BaseMemoryCache的成员变量，并且每次在操作的时候都会把bitmap的弱引用存进去
  2.  private final Map<String, Reference<Bitmap>> softMap = Collections.synchronizedMap(
  3.                 new HashMap<String, Reference<Bitmap>>());
  5. //LimitedMemoryCache的成员变量，缓存的bitmap是强引用
  6. private final List<Bitmap> hardCache = Collections.synchronizedList(new LinkedList<Bitmap>());

有人可能会有疑问了这些成员变量不是私有的吗？为什么说LimitedMemoryCache的子类，至少可以访问两份引用，这点我们可以从他们的put方法中知道

  1. @Override
  2. public boolean put(String key, Bitmap 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.          Bitmap removedValue = removeNext();
  11.          if (hardCache.remove(removedValue)) {
  12.             curCacheSize = cacheSize.addAndGet(-getSize(removedValue));
  13.          }
  14.       }
  15.       hardCache.add(value);
  16.       cacheSize.addAndGet(valueSize);
  18.       putSuccessfully = true;
  19.    }
  20.    // Add value to soft cache
  21.    super.put(key, value);
  22.    return putSuccessfully;
  23. }

同理LimitedMemoryCache的子类put也会调用LimitedMemoryCache的put方法，代码见下面分析。

同时从上面的分析当中我们可以知道主要关心put和removeNext（）这两个方法就可以了，put（）方法其实就是把bitmap对象存进我们的queue队列中

下面我们在看一下UsingFreqLimitedMemoryCache是怎样实现的？

  1. public class UsingFreqLimitedMemoryCache extends LimitedMemoryCache {
  2.     /**
  3.      * Contains strong references to stored objects (keys) and last object usage date (in milliseconds). If hard cache
  4.      * size will exceed limit then object with the least frequently usage is deleted (but it continue exist at
  5.      * {@link #softMap} and can be collected by GC at any time)
  6.      */
  7.     private final Map<Bitmap, Integer> usingCounts = Collections.synchronizedMap(new HashMap<Bitmap, Integer>());
  9.     public UsingFreqLimitedMemoryCache(int sizeLimit) {
  10.         super(sizeLimit);
  11.     }
  13.     @Override
  14.     public boolean put(String key, Bitmap value) {
  15.         if (super.put(key, value)) {
  16.             usingCounts.put(value, 0);
  17.             return true;
  18.         } else {
  19.             return false;
  20.         }
  21.     }
  23.     @Override
  24.     public Bitmap get(String key) {
  25.         Bitmap value = super.get(key);
  26.         // Increment usage count for value if value is contained in hardCahe
  27.         if (value != null) {
  28.             Integer usageCount = usingCounts.get(value);
  29.             if (usageCount != null) {
  30.                 usingCounts.put(value, usageCount + 1);
  31.             }
  32.         }
  33.         return value;
  34.     }
  36.     @Override
  37.     public Bitmap remove(String key) {
  38.         Bitmap value = super.get(key);
  39.         if (value != null) {
  40.             usingCounts.remove(value);
  41.         }
  42.         return super.remove(key);
  43.     }
  45.     @Override
  46.     public void clear() {
  47.         usingCounts.clear();
  48.         super.clear();
  49.     }
  51.     @Override
  52.     protected int getSize(Bitmap value) {
  53.         return value.getRowBytes() * value.getHeight();
  54.     }
  56.     @Override
  57.     protected Bitmap removeNext() {
  58.         Integer minUsageCount = null;
  59.         Bitmap leastUsedValue = null;
  60.         Set<Entry<Bitmap, Integer>> entries = usingCounts.entrySet();
  61.         synchronized (usingCounts) {
  62.             for (Entry<Bitmap, Integer> entry : entries) {
  63.                 if (leastUsedValue == null) {
  64.                     leastUsedValue = entry.getKey();
  65.                     minUsageCount = entry.getValue();
  66.                 } else {
  67.                     Integer lastValueUsage = entry.getValue();
  68.                     if (lastValueUsage < minUsageCount) {
  69.                         minUsageCount = lastValueUsage;
  70.                         leastUsedValue = entry.getKey();
  71.                     }
  72.                 }
  73.             }
  74.         }
  75.         usingCounts.remove(leastUsedValue);
  76.         return leastUsedValue;
  77.     }
  79.     @Override
  80.     protected Reference<Bitmap> createReference(Bitmap value) {
  81.         return new WeakReference<Bitmap>(value);
  82.     }
  83. }

思路解析

  1. 当我们调用put方法，把bitmap存进内存的时候，他会判断是否超出我们的最大值，超出我们的最大值就会调用removeNext();来获得我们将要移除的bitmap对象，最终再调用hardCache.remove(removedValue)去移除它。

    1. @Override
    2. public boolean put(String key, Bitmap 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.      Bitmap removedValue = removeNext();
    11.      if (hardCache.remove(removedValue)) {
    12.         curCacheSize = cacheSize.addAndGet(-getSize(removedValue));
    13.      }
    14.   }
    15.   hardCache.add(value);
    16.   cacheSize.addAndGet(valueSize);
    18.   putSuccessfully = true;
    19. }
    20. // Add value to soft cache
    21. super.put(key, value);
    22. return putSuccessfully;
    23. }
    25. ···
    27. * 下面我们来看一下removeNext()是怎样获得将要移除的bitmap对象的？
    29. ```java
    30. private final Map<Bitmap, Integer> usingCounts = Collections.
    31.                          synchronizedMap(new HashMap<Bitmap, Integer>());
    34. @Override
    35. protected Bitmap removeNext() {
    36. Integer minUsageCount = null;
    37. Bitmap leastUsedValue = null;
    38. Set<Entry<Bitmap, Integer>> entries = usingCounts.entrySet();
    39. synchronized (usingCounts) {
    40.   for (Entry<Bitmap, Integer> entry : entries) {
    41.      if (leastUsedValue == null) {
    42.         leastUsedValue = entry.getKey();
    43.         minUsageCount = entry.getValue();
    44.      } else {
    45.         Integer lastValueUsage = entry.getValue();
    46.         if (lastValueUsage < minUsageCount) {
    47.            minUsageCount = lastValueUsage;
    48.            leastUsedValue = entry.getKey();
    49.         }
    50.      }
    51.   }
    52. }
    53. usingCounts.remove(leastUsedValue);
    54. return leastUsedValue;
    55. }

    其实就是将usingCounts中出现次数最少的节点移除掉。

    那它实在什么时候计算bitmap的使用次数的呢？相信大多数人会想到，既然是使用频率，那肯定是在取图片的过程中计算的，没错，下面让我们一起来看一下是怎样实现的？

    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. }

    其实也很简单，判断是否存在缓存value，存在的话，使用次数加一

    好的，到此UsingFreqLimitedMemoryCache的源码分析位置

FIFOLimitedMemoryCache源码分析

  1. public class FIFOLimitedMemoryCache extends LimitedMemoryCache {
  3.     private final List<Bitmap> queue = Collections.synchronizedList(new LinkedList<Bitmap>());
  5.     public FIFOLimitedMemoryCache(int sizeLimit) {
  6.         super(sizeLimit);
  7.     }
  9.     @Override
  10.     public boolean put(String key, Bitmap value) {
  11.         if (super.put(key, value)) {
  12.             queue.add(value);
  13.             return true;
  14.         } else {
  15.             return false;
  16.         }
  17.     }
  19.     @Override
  20.     public Bitmap remove(String key) {
  21.         Bitmap value = super.get(key);
  22.         if (value != null) {
  23.             queue.remove(value);
  24.         }
  25.         return super.remove(key);
  26.     }
  28.     @Override
  29.     public void clear() {
  30.         queue.clear();
  31.         super.clear();
  32.     }
  34.     @Override
  35.     protected int getSize(Bitmap value) {
  36.         return value.getRowBytes() * value.getHeight();
  37.     }
  39.     @Override
  40.     protected Bitmap removeNext() {
  41.         return queue.remove(0);
  42.     }
  44.     @Override
  45.     protected Reference<Bitmap> createReference(Bitmap value) {
  46.         return new WeakReference<Bitmap>(value);
  47.     }
  48. }
  1. public class LargestLimitedMemoryCache extends LimitedMemoryCache {
  2.     /**
  3.      * Contains strong references to stored objects (keys) and sizes of the objects. If hard cache
  4.      * size will exceed limit then object with the largest size is deleted (but it continue exist at
  5.      * {@link #softMap} and can be collected by GC at any time)
  6.      */
  7.     private final Map<Bitmap, Integer> valueSizes = Collections.synchronizedMap(new HashMap<Bitmap, Integer>());
  9.     public LargestLimitedMemoryCache(int sizeLimit) {
  10.         super(sizeLimit);
  11.     }
  13.     @Override
  14.     public boolean put(String key, Bitmap value) {
  15.         if (super.put(key, value)) {
  16.             valueSizes.put(value, getSize(value));
  17.             return true;
  18.         } else {
  19.             return false;
  20.         }
  21.     }
  23.     @Override
  24.     public Bitmap remove(String key) {
  25.         Bitmap value = super.get(key);
  26.         if (value != null) {
  27.             valueSizes.remove(value);
  28.         }
  29.         return super.remove(key);
  30.     }
  33.  //这里我们省略若干个方法，有兴趣的话讲源码去，下面有提供源码下载地址
  34.     @Override
  35.     protected Bitmap removeNext() {
  36.         Integer maxSize = null;
  37.         Bitmap largestValue = null;
  38.         Set<Entry<Bitmap, Integer>> entries = valueSizes.entrySet();
  39.         synchronized (valueSizes) {
  40.             for (Entry<Bitmap, Integer> entry : entries) {
  41.                 if (largestValue == null) {
  42.                     largestValue = entry.getKey();
  43.                     maxSize = entry.getValue();
  44.                 } else {
  45.                     Integer size = entry.getValue();
  46.                     if (size > maxSize) {
  47.                         maxSize = size;
  48.                         largestValue = entry.getKey();
  49.                     }
  50.                 }
  51.             }
  52.         }
  53.         valueSizes.remove(largestValue);
  54.         return largestValue;
  55.     }
  57. }

同样我们只关心put方法和removeNext（）方法

  1. @Override
  2. public boolean put(String key, Bitmap value) {
  3.     if (super.put(key, value)) {
  4.          valueSizes.put(value, getSize(value));
  5.          return true;
  6.     }else {
  7.          return false;
  8.     }
  9. }
  11. @Override
  12. protected Bitmap removeNext() {
  13.    Integer maxSize = null;
  14.    Bitmap largestValue = null;
  15.    Set<Entry<Bitmap, Integer>> entries = valueSizes.entrySet();
  16.    synchronized (valueSizes) {
  17.       for (Entry<Bitmap, Integer> entry : entries) {
  18.          if (largestValue == null) {
  19.             largestValue = entry.getKey();
  20.             maxSize = entry.getValue();
  21.          } else {
  22.             Integer size = entry.getValue();
  23.             if (size > maxSize) {
  24.                maxSize = size;
  25.                largestValue = entry.getKey();
  26.             }
  27.          }
  28.       }
  29.    }
  30.    valueSizes.remove(largestValue);
  31.    return largestValue;
  32. }

下面我们来看一下LruMemoryCache是怎样实现的

源码我们就不贴出来了
主要逻辑在put方法中

  1. // 存储bitmap对象，在构造方法里面初始化
  2. private final LinkedHashMap<String, Bitmap> map;
  5. /** Caches {@code Bitmap} for {@code key}. The Bitmap is moved to the head of the queue. */
  6. @Override
  7. public final boolean put(String key, Bitmap value) {
  8.    if (key == null || value == null) {
  9.       throw new NullPointerException("key == null || value == null");
  10.    }
  12.    synchronized (this) {
  13.       size += sizeOf(key, value);
  14.       Bitmap previous = map.put(key, value);
  15.       if (previous != null) {
  16.          size -= sizeOf(key, previous);
  17.       }
  18.    }
  20.    trimToSize(maxSize);
  21.    return true;
  22. }

当我们把bitmap存进内存的时候，他会trimToSize(maxSize)这个方法去判断我们是否超过我们规定内存的最大值，超过的话移除掉最先添加进来的那个

  1. private void trimToSize(int maxSize) {
  2.    while (true) {
  3.       String key;
  4.       Bitmap value;
  5.       synchronized (this) {
  6.          if (size < 0 || (map.isEmpty() && size != 0)) {
  7.             throw new IllegalStateException(getClass().getName() + ".sizeOf() is reporting inconsistent results!");
  8.          }
  10.          if (size <= maxSize || map.isEmpty()) {
  11.             break;
  12.          }
  14.          Map.Entry<String, Bitmap> toEvict = map.entrySet().iterator().next();
  15.          if (toEvict == null) {
  16.             break;
  17.          }
  18.          key = toEvict.getKey();
  19.          value = toEvict.getValue();
  20.          map.remove(key);
  21.          size -= sizeOf(key, value);
  22.       }
  23.    }
  24. }

下面我们来看一下LimitedAgeMemoryCache 是怎样实现的

  1. /**
  2.  * Decorator for {@link MemoryCache}. Provides special feature for cache: if some cached object age exceeds defined
  3.  * value then this object will be removed from cache.
  4.  *
  5.  * 采用装饰着模式，计算对象的最大存活时间
  6.  * 在get方法的时候判断大于的移除掉
  7.  *
  8.  */
  9. public class LimitedAgeMemoryCache implements MemoryCache {
  11.     private final MemoryCache cache;
  13.     private final long maxAge;
  14.     private final Map<String, Long> loadingDates = Collections.synchronizedMap(new HashMap<String, Long>());
  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(MemoryCache cache, long maxAge) {
  22.         this.cache = cache;
  23.         this.maxAge = maxAge * 1000; // to milliseconds
  24.     }
  26.     @Override
  27.     public boolean put(String key, Bitmap value) {
  28.         boolean putSuccesfully = cache.put(key, value);
  29.         if (putSuccesfully) {
  30.             loadingDates.put(key, System.currentTimeMillis());
  31.         }
  32.         return putSuccesfully;
  33.     }
  35.     @Override
  36.     public Bitmap get(String key) {
  37.         Long loadingDate = loadingDates.get(key);
  38.         if (loadingDate != null && System.currentTimeMillis() - loadingDate > maxAge) {
  39.             cache.remove(key);
  40.             loadingDates.remove(key);
  41.         }
  43.         return cache.get(key);
  44.     }
  46.     @Override
  47.     public Bitmap remove(String key) {
  48.         loadingDates.remove(key);
  49.         return cache.remove(key);
  50.     }
  52.     @Override
  53.     public Collection<String> keys() {
  54.         return cache.keys();
  55.     }
  57.     @Override
  58.     public void clear() {
  59.         cache.clear();
  60.         loadingDates.clear();
  61.     }
  62. }

分析

  1. //成员变量，保持存活时间的map集合
  2. private final Map<String, Long> loadingDates = Collections.synchronizedMap(
  3.                                                       new HashMap<String, Long>());
  5. @Override
  6. public boolean put(String key, Bitmap value) {
  7.    boolean putSuccesfully = cache.put(key, value);
  8.    if (putSuccesfully) {
  9.       loadingDates.put(key, System.currentTimeMillis());
  10.    }
  11.    return putSuccesfully;
  12. }

感觉ImageLoader在实现FIFOLimitedMemoryCache算法的时候还是有一点缺陷，为什么呢？

到此ImageLoader内存的缓存算法源码分析为止，下面我稍微改一下实现方式，内存里面不再保存着两份引用了，bitmap的缓存只保存着一份引用。

自己实现的内存缓存算法

类UML图

其实跟ImageLoader实现的也没有多大区别，只是我去除了弱引用，每个实现类里面不像LimitedMemoryCache的实现类一样持有两份引用而已

首先我们来看一下LimitedMemoryCache是怎样实现的

  1. public abstract class LimitedMemoryCache implements MemoryCache {
  3.     private static final int MAX_NORMAL_CACHE_SIZE_IN_MB = 16;
  4.     private static final int MAX_NORMAL_CACHE_SIZE = MAX_NORMAL_CACHE_SIZE_IN_MB * 1024 * 1024;
  6.     private final int sizeLimit;
  7.      public static final String TAG="tag";
  9.     private final AtomicInteger cacheSize;
  11.     private final Map<String, Bitmap> mMap= Collections.synchronizedMap(new LinkedHashMap<String, Bitmap>());
  15.     public LimitedMemoryCache(int sizeLimit) {
  16.         this.sizeLimit = sizeLimit;
  18.         cacheSize = new AtomicInteger();
  19.         if (sizeLimit > MAX_NORMAL_CACHE_SIZE) {
  20.             Log.w(TAG,"You set too large memory cache size (more than %1$d Mb)"+ MAX_NORMAL_CACHE_SIZE_IN_MB);
  21.         }
  23.     }
  25.     @Override
  26.     public boolean put(String key, Bitmap value) {
  27.         boolean putSuccessfully = false;
  28.         // Try to add value to hard cache
  29.         int valueSize = getSize(value);
  30.         int sizeLimit = getSizeLimit();
  31.         int curCacheSize = cacheSize.get();
  32.         if (valueSize < sizeLimit) {
  33.             while (curCacheSize + valueSize > sizeLimit) {
  34.                 String removeKey = removeNext();
  35.                 if(removeKey==null){
  36.                    break;
  37.                 }
  38.                 Bitmap bitmap = mMap.remove(key);
  39.                 if(bitmap!=null){
  40.                     curCacheSize = cacheSize.addAndGet(-getSize(bitmap));
  41.                 }
  42.             }
  43.             mMap.put(key,value);
  44.             cacheSize.addAndGet(valueSize);
  45.             putSuccessfully = true;
  46.         }
  48.         return putSuccessfully;
  49.     }
  51.     @Override
  52.     public Bitmap remove(String key) {
  53.         return  mMap.remove(key);
  54.     }
  56.     @Override
  57.     public Bitmap get(String key) {
  58.         return mMap.get(key);
  59.     }
  61.     @Override
  62.     public void clear() {
  63.         mMap.clear();
  64.         cacheSize.set(0);
  65.     }
  67.     protected int getSizeLimit() {
  68.         return sizeLimit;
  69.     }
  71.     @Override
  72.     public Collection<String> keys() {
  73.         synchronized (mMap) {
  74.             return new HashSet<String>(mMap.keySet());
  75.         }
  76.     }
  78.     protected abstract int getSize(Bitmap value);
  80.     protected abstract String removeNext();
  81. }

LimitedMemoryCache所做的工作可以分为以下几步

  1. //在构造方法里面初始化      
  2. private final Map<String, Bitmap> mMap;

下面我们来看一下

  1. public class UsingFreqLimitedMemoryCache extends LimitedMemoryCache {
  3.     private final Map<String, Integer> usingCounts = Collections.synchronizedMap(new HashMap<String, Integer>());
  5. //这里省略了若干个方法
  6.     @Override
  7.     public boolean put(String key, Bitmap value) {
  8.         if (super.put(key, value)) {
  9.             usingCounts.put(key, 0);
  10.             return true;
  11.         } else {
  12.             return false;
  13.         }
  14.     }
  16.     @Override
  17.     public Bitmap get(String key) {
  18.         Bitmap value = super.get(key);
  19.         // Increment usage count for value if value is contained in hardCahe
  20.         if (value != null) {
  21.             Integer usageCount = usingCounts.get(value);
  22.             if (usageCount != null) {
  23.                 usingCounts.put(key, usageCount + 1);
  24.             }
  25.         }
  26.         return value;
  27.     }
  29.     @Override
  30.     public Bitmap remove(String key) {
  31.         usingCounts.remove(key);
  32.         return super.remove(key);
  33.     }
  36.     @Override
  37.     protected String removeNext() {
  38.         Integer minUsageCount = null;
  39.         String leastUsedValue = null;
  40.         Set<Entry<String, Integer>> entries = usingCounts.entrySet();
  41.         synchronized (usingCounts) {
  42.             for (Entry<String, Integer> entry : entries) {
  43.                 if (leastUsedValue == null) {
  44.                     leastUsedValue = entry.getKey();
  45.                     minUsageCount = entry.getValue();
  46.                 } else {
  47.                     Integer lastValueUsage = entry.getValue();
  48.                     if (lastValueUsage < minUsageCount) {
  49.                         minUsageCount = lastValueUsage;
  50.                         leastUsedValue = entry.getKey();
  51.                     }
  52.                 }
  53.             }
  54.         }
  55.         usingCounts.remove(leastUsedValue);
  56.         return leastUsedValue;
  57.     }
  59. }

与ImageLoader不同的是,我们是用这个记录

  1. private final Map<String, Integer> usingCounts = Collections.synchronizedMap(new HashMap<String, Integer>());

而ImageLoader是用这种类型的记录，其他的基本大同小异，有兴趣的可以去这里下载源码。

  1. private final Map<Bitmap, Integer> usingCounts = Collections.synchronizedMap(new HashMap<Bitmap, Integer>());

题外话：通过这篇博客，学习了更多的缓存算法，同时你们有没有发现，很多地方都用到了Collection框架，而要用好这些，个人觉得去了解他们的原理是非常必要的，尤其是map和List集合，不管说是初学者还是大牛，毕竟万丈高楼也是从平地盖起的，基础非常重要

转载请注明原博客地址： http://blog.csdn.net/gdutxiaoxu/article/details/51914000

源码参考地址 ImagerLoader:https://github.com/nostra13/Android-Universal-Image-Loader

源码下载地址： https://github.com/gdutxiaoxu/library_algorithm.git

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注