Bitmap 内存缓存框架(二)

内存达到限制优先清理占据内存最大的bimap方案LargestLimitedMemoryCache

/**
 * @描述：限定内存缓存大小，内存超出 优先清理bitmap占据内存最大的
 * @filename：LargestLimitedMemoryCache.java
 * @author：gac
 * @time：2018/6/29 11:19
 */
public class LargestLimitedMemoryCache extends LimitedMemoryCache{
    //强引用记录bitmap对象，和对应占据的尺寸 超出限制优先删除最大的bitmap
    private final Map<Bitmap,Integer> valueSizes = Collections.synchronizedMap(new HashMap<Bitmap, Integer>());
    public LargestLimitedMemoryCache(int sizeLimit) {
        super(sizeLimit);
    }

    @Override
    public boolean put(String key, Bitmap value) {
        if(super.put(key,value)){//super.put 会根据内存大小进行清理内存，调用removeNext 保存元素成功
            valueSizes.put(value,getSize(value));//记录bitmap对象 和bitmap的尺寸
            return true;
        }
        return false;
    }

    @Override
    public Bitmap remove(String key) {
        Bitmap value =super.get(key);
        if(value != null){
            valueSizes.remove(value);
        }

        return super.remove(key);
    }

    @Override
    public void clear() {
        valueSizes.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() {
        Integer maxSize = null;//最大bimap尺寸
        Bitmap largestValue = null;//最大bitmap尺寸对象
        Set<Map.Entry<Bitmap,Integer>> entries = valueSizes.entrySet();
        //同步valueSizes 执行此操作 为了数据的正确性其它线程不允许操作
        synchronized (valueSizes){
            for(Map.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;
    }
}

内存达到限制，优先清理最新的数据，采取队列存储bitmap强引用FIFOLimitedMemoryCache

/**
 * @描述：限制内存大小的情况下,队列保存bitmap 先保存的优先被删除
 * @filename：FIFOLimitedMemoryCache.java
 * @author：gac
 * @time：2018/6/29 13:30
 */
public class FIFOLimitedMemoryCache extends LimitedMemoryCache {
    //链表保存bitmap强引用 如果内存不够 优先删除队列头的元素
    private final List<Bitmap> queue = Collections.synchronizedList(new LinkedList<Bitmap>());

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

    /**
     * 保存元素
     * @param key
     * @param value
     * @return
     */
    @Override
    public boolean put(String key, Bitmap value) {
        if(super.put(key,value)){
            queue.add(value);
            return true;
        }
        return false;
    }

    /**
     * 删除元素
     * @param key
     * @return
     */
    @Override
    public Bitmap remove(String key) {
        Bitmap value = super.get(key);
        if(value != null){
            queue.remove(value);
        }
        return super.remove(key);
    }

    @Override
    public void clear() {
        queue.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() {//强引用删除，softMap保留引用 会自己被系统回收
        return queue.remove(0);
    }
}