Bitmap内存缓存框架(一)

UniverseImageLoader加载图片首先从内存加载，对于其使用的内存缓存框架可以拿来自己用，也值得去看一下它的实现。

首先实现一个通用的内存框架的接口MemoryCache

/**
 * @描述：cache接口
 * @filename：MemoryCache.java
 * @author：gac
 * @time：2018/6/28 16:03
 */
public interface MemoryCache {
    /**
     * 根据key值存储元素
     * @param key
     * @param value
     * @return
     */
    boolean put(String key,Bitmap value);

    /**
     * 获取元素
     * @param key
     * @return
     */
    Bitmap get(String key);

    /**
     * 删除元素 返回被删除的元素
     * @param key
     * @return
     */
    Bitmap remove(String key);

    /**
     * 获取keys 集合
     * @return
     */
    Collection<String> keys();

    /**
     * 清空缓存
     */
    void clear();
}

提供一个基类BaseMemoryCache

/**
 * @描述：基础memoryCache实现
 * @filename：BaseMemoryCache.java
 * @author：gac
 * @time：2018/6/28 16:07
 */
public abstract class BaseMemoryCache implements MemoryCache {
    //提供弱引用 缓存bitmap 可回收 采用synchornizedMap解决并发问题
    private final Map<String,Reference<Bitmap>> softMap = Collections.synchronizedMap(new HashMap<String, Reference<Bitmap>>());

    /**
     * 存储bitmap
     * @param key
     * @param value
     * @return
     */
    @Override
    public boolean put(String key, Bitmap value) {
        softMap.put(key,createReference(value));
        return true;
    }

    /**
     * 获取bitmap
     * @param key
     * @return
     */
    @Override
    public Bitmap get(String key) {
        Bitmap result = null;
        Reference<Bitmap> reference = softMap.get(key);
        if(reference != null){
            result = reference.get();
        }
        return result;
    }

    @Override
    public Bitmap remove(String key) {
        Reference<Bitmap> bmpRef = softMap.remove(key);
        return bmpRef == null ? null : bmpRef.get();
    }

    /**
     * 获取键的集合 当有线程对softMap对象执行该操作时候 只有该线程可以操作该对象 不允许其它线程 调用put remove等修改方法
     * @return
     */
    @Override
    public Collection<String> keys() {
        synchronized (softMap){
            return new HashSet<String>(softMap.keySet());
        }
    }

    /**
     * 清空内存缓存
     */
    @Override
    public void clear() {
        softMap.clear();
    }

    /**
     * 创建Bitmap 弱引用对象
     * @param value
     * @return
     */
    protected abstract Reference<Bitmap> createReference(Bitmap value);

}

下面介绍几种缓存策略:第一种根据使用频率去对bitmap对象进行删除，使用次数最少的优先被删除
UsingFreqLimitedMemoryCache

/**
 * @描述：限定大小存储bitmap 缓存达到限制 根据使用频率进行删除
 * @filename：UsingFreqLimitedMemoryCache.java
 * @author：gac
 * @time：2018/6/28 17:53
 */
public class UsingFreqLimitedMemoryCache extends LimitedMemoryCache{
    /**
     * 记录每个bitmap 的使用次数 强引用bitmap bitmap删除后 softMap中会自己被内存回收
     */
    private final Map<Bitmap,Integer> usingCounts = Collections.synchronizedMap(new HashMap<Bitmap,Integer>());

    public UsingFreqLimitedMemoryCache(int sizeLimit){
        super(sizeLimit);
    }

    @Override
    public boolean put(String key, Bitmap value) {
        if(super.put(key,value)){//如果保存成功 则设置bitmap使用次数是0 只要更新了对象
            usingCounts.put(value,0);
            return true;
        }else{
            return false;
        }
    }

    @Override
    public Bitmap get(String key) {
        Bitmap value = super.get(key);
        if(value != null){//需要判空 弱引用随时可能被回收
            Integer usageCount = usingCounts.get(value);
            if(usageCount != null){//put 方法可能会失败 需要判空
                usingCounts.put(value,usageCount+1);
            }
        }
        return value;
    }

    @Override
    public Bitmap remove(String key) {
        Bitmap value = super.get(key);
        if(value != null){
            usingCounts.remove(value);//删除元素 删除计数器的强引用
        }
        return super.remove(key);
    }

    @Override
    public void clear() {
        usingCounts.clear();
        super.clear();
    }

    @Override
    protected int getSize(Bitmap value) {
        return value.getRowBytes()*value.getHeight();
    }

    @Override
    protected Bitmap removeNext() {
        Integer minUsageCount = null;//最少使用次数记录器
        Bitmap leastUsedValue = null;//最少使用次数bitmap记录器
        Set<Map.Entry<Bitmap,Integer>> entries = usingCounts.entrySet();
        synchronized (usingCounts){//对usingCounts进行查找操作 时候 不允许对usingCounts进行其它操作
            for(Map.Entry<Bitmap,Integer> entry : entries){
                if(leastUsedValue == null){//第一次执行的时候 初始化 minUssageCount leastUsedValue为第一个值
                    leastUsedValue = entry.getKey();
                    minUsageCount = entry.getValue();
                }else{
                    Integer lastValueUsage = entry.getValue();//获取下一个元素的 使用次数
                    if(lastValueUsage < minUsageCount){//如果下一个元素使用次数更新 指针偏移
                        minUsageCount = lastValueUsage;
                        leastUsedValue = entry.getKey();
                    }
                }
            }//找到使用次数最少的bitmap
        }
        usingCounts.remove(leastUsedValue);
        return leastUsedValue;
    }

    @Override
    protected Reference<Bitmap> createReference(Bitmap value) {
        return new WeakReference<Bitmap>(value);
    }
}

限制内存大小，超过最大内存缓存的时候，增加元素就会清除元素直到内存达到限制要求LimitedMemoryCache

/**
 * @描述：限制内存大小的bitmap缓存基础类
 * @filename：LimitedMemoryCache.java
 * @author：gac
 * @time：2018/6/28 16:44
 */
public abstract class LimitedMemoryCache extends BaseMemoryCache {
    private static final int MAX_NORMAL_SIZE_IN_MB = 16;//默认最大内存缓存 M单位
    private static final int MAX_NORMAL_CACHE_SIZE = MAX_NORMAL_SIZE_IN_MB*1024*1024;//最大缓存字节数
    private final int sizeLimit;//用户设置的缓存限制大小
    private final AtomicInteger cacheSize;//当前内存缓存数量
    /*强引用对象存储 缓存的bitmap集合,添加则添加集合的尾部,如果超过限定的缓存 则会删除集合第一个元素，一直
    * 达到内存到达限定大小，即使删除了内存的缓存 BaseMemoryCache softMap依然存在Bitmap的弱引用
    * 但是可以被gc 在任何时候回收掉
    * */
    private final List<Bitmap> hardCache = Collections.synchronizedList(new LinkedList<Bitmap>());
    public LimitedMemoryCache(int sizeLimit){
        this.sizeLimit = sizeLimit;
        cacheSize = new AtomicInteger();
        if(sizeLimit > MAX_NORMAL_CACHE_SIZE){
            Log.e("cache","you set too large memory cache size(more than 16MB");
        }
    }

    @Override
    public boolean put(String key, Bitmap value) {
        boolean putSuccessfully = false;
        int valueSize = getSize(value);//计算存储的bitmap的大小
        int sizeLimit = getSizeLimit();//获取用户设置的缓存大小
        int curCacheSize = cacheSize.get();//当前已经占用的缓存大小
        if(valueSize < sizeLimit){//设置的bitmap小于设置的缓存
            while (curCacheSize + valueSize > sizeLimit){//如果缓存超出了则调用removeNext删除对象
                Bitmap removedValue = removeNext();//获取需要删除的bitmap
                if(hardCache.remove(removedValue)){//删除 list 强引用 softMap中还存在 等待gc 自动回收
                    curCacheSize = cacheSize.addAndGet(-getSize(removedValue));
                }
                hardCache.add(value);//添加list 强引用
                cacheSize.addAndGet(valueSize);//更新当前缓存数
                putSuccessfully = true;
            }

        }
        super.put(key, value);//add bitmap to softCache
        return putSuccessfully;
    }

    @Override
    public Bitmap remove(String key) {
        Bitmap value = super.get(key);
        if(value != null){
            if(hardCache.remove(value)){//删除强引用
                cacheSize.addAndGet(-getSize(value));//更新当前缓存值
            }
        }
        return super.remove(key);//删除弱引用
    }

    /**
     * 清空缓存
     */
    @Override
    public void clear() {
        hardCache.clear();
        cacheSize.set(0);
        super.clear();
    }

    /**
     * 获取bitmap大小的计算方法
     * @param value
     * @return
     */
    protected abstract int getSize(Bitmap value);

    /**
     * 删除缓存的bitmap算法 核心
     * @return
     */
    protected abstract Bitmap removeNext();

    /**
     * 获取用户设置的默认缓存大小
     * @return
     */
    protected int getSizeLimit(){
        return sizeLimit;
    }

根据元素访问次序进行删除，很少被访问的元素优先被清理,LruMemoryCache

/**
 * @描述：根据元素的访问顺序进行移除元素
 * 经常被访问的不会删除，很少访问的会被优先删除
 * @filename：LruMemoryCache.java
 * @author：gac
 * @time：2018/6/29 9:10
 */
public class LruMemoryCache implements MemoryCache{
    //LinkedHashMap 每一次调用put方法 或者 get方法 都会将访问的元素放在链表尾部
    //也就是 访问的元素都是最长没有被访问过的元素
    private final LinkedHashMap<String,Bitmap> map;
    private final int maxSize;//最大内存缓存数量
    private int size;//记录当前已经缓存的内存数量

    //设置最大内存缓存 初始化map
    public LruMemoryCache(int maxSize){
        if(maxSize <= 0){
            throw new IllegalArgumentException("maxSize <= 0");
        }
        this.maxSize = maxSize;
        this.map = new LinkedHashMap<String,Bitmap>(0,0.75f,true);
    }
    @Override
    public boolean put(String key, Bitmap value) {
        if(key == null || value == null){
            throw new NullPointerException("key == null || value == null ");
        }
        //同步代码块 对LruMemoryCache加锁 如果执行这里 不允许进行其它操作，防止改变当前size的值，造成不准确
        synchronized (this){
            size+=sizeOf(key,value);
            Bitmap previous = map.put(key,value);//获取先前保存的bitmap
            if(previous != null){
                size-= sizeOf(key,value);//减去被更新的bitmap的容量
            }
        }
        trimToSize(maxSize);
        return true;
    }
    //对内存进行清理
    private void trimToSize(int maxSize){
        while (true){
            String key;
            Bitmap value;
            /**
             * 同步代码块，清理内存的时候，不允许其它类对LurMemoryCache进行操作
             */
            synchronized (this){
                if(size < 0 || (map.isEmpty() && size != 0)){
                    throw new IllegalStateException(getClass().getSimpleName()+".sizeOf() is reporting inconsistent results!");
                }
                if(size <= maxSize || map.isEmpty()){
                    break;
                }
                Map.Entry<String,Bitmap> toEvict = map.entrySet().iterator().next();//不断获取btimap下一个元素(很少访问的元素最先获取)
                if(toEvict == null){
                    break;
                }
                key = toEvict.getKey();
                value = toEvict.getValue();
                map.remove(value);//删除value
                size-=sizeOf(key,value);//更新当前缓存
            }
        }
    }
    @Override
    public Bitmap get(String key) {
        if(key == null){
            throw new NullPointerException("key == null");
        }
        //同步LruMemoryCache对象 如果执行这里 不允许对map进行其它操作
        synchronized (this){
            return map.get(key);
        }


    }

    @Override
    public Bitmap remove(String key) {
        if(key == null){
            throw new NullPointerException("key == null");
        }
        synchronized (this){//对map进行更新操作 同步代码块 防止错误发生
            Bitmap previous = map.remove(key);//获取被删除的元素
            if(previous != null){
                size -= sizeOf(key,previous);//更新当前内存
            }
            return previous;
        }
    }

    @Override
    public Collection<String> keys() {
        //同步代码块  防止keys 由于其他线程 防止变化
        synchronized (this){
            return new HashSet<String>(map.keySet());
        }
    }


    /**
     * 记录bitmap大小
     * @param key
     * @param value
     * @return
     */
    private int sizeOf(String key, Bitmap value) {
        return value.getRowBytes() * value.getHeight();
    }
    @Override
    public void clear() {
        trimToSize(-1);
    }

    @Override
    public synchronized final String toString() {
        return String.format("LruCache[maxSize=%d]", maxSize);
    }
}

对内存大小进行限制，根据访问顺序去清理内存，很少访问的元素优先被清理，LRULimitedMemoryCache

/**
 * @描述：对内存大小进行了限制 最大16M
 * LruMemoryCache可以手动设置最大内存
 * @filename：LRULimitedMemoryCache.java
 * @author：gac
 * @time：2018/6/29 9:55
 */
public class LRULimitedMemoryCache extends LimitedMemoryCache {
    private static final int INITIAL_CAPACITY = 10;//初始化LinkHashMap容器大小
    private static final float LOAD_FACTOR = 1.1f;//LinkedHashMap 容器重置时候增大的比例
    //lruCache 强引用保存元素 使用LinkedHashMap保证 很少访问的元素被优先删除
    private final Map<String,Bitmap> lruCache = Collections.synchronizedMap(
            new LinkedHashMap<String, Bitmap>(INITIAL_CAPACITY,LOAD_FACTOR)
    );
    public LRULimitedMemoryCache(int sizeLimit) {
        super(sizeLimit);
    }

    @Override
    public boolean put(String key, Bitmap value) {
        if(super.put(key,value)){
            lruCache.put(key,value);
            return true;
        }else{
            return false;
        }
    }

    @Override
    public Bitmap remove(String key) {
        lruCache.remove(key);
        return super.remove(key);
    }

    @Override
    public void clear() {
        lruCache.clear();
        super.clear();
    }

    @Override
    protected Reference<Bitmap> createReference(Bitmap value) {
        return new WeakReference<Bitmap>(value);
    }

    @Override
    protected int getSize(Bitmap value) {
        return value.getRowBytes()*value.getHeight();
    }

    @Override
    protected Bitmap removeNext() {
        Bitmap mostLoginUsedValue = null;//最长没有被使用过的元素
        //同步代码块lruCache 防止删除元素的时候其它线程进行更新操作
        synchronized (lruCache){
            Iterator<Map.Entry<String,Bitmap>> it = lruCache.entrySet().iterator();
            if(it.hasNext()){
                Map.Entry<String,Bitmap> entry = it.next();
                mostLoginUsedValue = entry.getValue();
                it.remove();
            }
        }
        return mostLoginUsedValue;
    }
}

设置保存时间，根据保存时间有没有过期去清理元素LimitedAgeMemoryCache

/**
 * @描述：根据设置保存元素的时间 去清理内存
 * @filename：LimitedAgeMemoryCache.java
 * @author：gac
 * @time：2018/6/29 10:09
 */
public class LimitedAgeMemoryCache implements MemoryCache{
    private final MemoryCache cache;//设置的底层缓存原理 可以是任何一种实现MemoryCache接口的方案
    private final long maxAge;//元素需要保存的时间 单位秒
    //存储bitmap的key值和保存元素的时间
    private final Map<String,Long> loadingDates = Collections.synchronizedMap(new HashMap<String, Long>());
    //构造方法 初始化统一的保存时间 和底层缓存原理
    public LimitedAgeMemoryCache(MemoryCache cache,long maxAge){
        this.cache = cache;
        this.maxAge = maxAge*1000;//转换为毫秒
    }
    @Override
    public boolean put(String key, Bitmap value) {
        boolean putSuccessfully = cache.put(key,value);
        if(putSuccessfully){
            loadingDates.put(key,System.currentTimeMillis());//保存元素的key 和当前时间戳
        }
        return putSuccessfully;
    }

    @Override
    public Bitmap get(String key) {
        Long loadingDate = loadingDates.get(key);
        //如果元素保存的时长 大于maxAge 则删除元素
        if(loadingDate != null && System.currentTimeMillis() -loadingDate > maxAge){
            cache.remove(key);
            loadingDates.remove(key);
        }
        return cache.get(key);//获取元素
    }

    @Override
    public Bitmap remove(String key) {
        loadingDates.remove(key);
        return cache.remove(key);
    }

    @Override
    public Collection<String> keys() {
        return cache.keys();
    }

    @Override
    public void clear() {
        cache.clear();
        loadingDates.clear();
    }
}