关闭

Android中LruCach的原理

标签: androidurllrucache
19164人阅读 评论(1) 收藏 举报



public class LruCache<K, V> {
    //缓存 map 集合,为什么要用LinkedHashMap
    //因为没错取了缓存值之后,都要进行排序,以确保
    //下次移除的是最少使用的值
    private final LinkedHashMap<K, V> map;
    //当前缓存的值
    private int size;
    //最大值
    private int maxSize;
    //添加到缓存中的个数
    private int putCount;
    //创建的个数
    private int createCount;
    //被移除的个数
    private int evictionCount;
    //命中个数
    private int hitCount;
    //丢失个数
    private int missCount;

    //实例化 Lru,需要传入缓存的最大值
    //这个最大值可以是个数,比如对象的个数,也可以是内存的大小
    //比如,最大内存只能缓存5兆
    public LruCache(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }
        this.maxSize = maxSize;
        this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
    }

    //重置最大缓存的值
    public void resize(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }

        synchronized (this) {
            this.maxSize = maxSize;
        }
        trimToSize(maxSize);
    }

    //通过 key 获取缓存值
    public final V get(K key) {
        if (key == null) {
            throw new NullPointerException("key == null");
        }

        V mapValue;
        synchronized (this) {
            mapValue = map.get(key);
            if (mapValue != null) {
                hitCount++;
                return mapValue;
            }
            missCount++;
        }


        //如果没有,用户可以去创建
        V createdValue = create(key);
        if (createdValue == null) {
            return null;
        }

        synchronized (this) {
            createCount++;
            mapValue = map.put(key, createdValue);

            if (mapValue != null) {
                // There was a conflict so undo that last put
                map.put(key, mapValue);
            } else {
                //缓存的大小改变
                size += safeSizeOf(key, createdValue);
            }
        }
        //这里没有移除,只是改变了位置
        if (mapValue != null) {
            entryRemoved(false, key, createdValue, mapValue);
            return mapValue;
        } else {
            //判断缓存是否越界
            trimToSize(maxSize);
            return createdValue;
        }
    }

    //添加缓存,跟上面这个方法的 create 之后的代码一样的
    public final V put(K key, V value) {
        if (key == null || value == null) {
            throw new NullPointerException("key == null || value == null");
        }

        V previous;
        synchronized (this) {
            putCount++;
            size += safeSizeOf(key, value);
            previous = map.put(key, value);
            if (previous != null) {
                size -= safeSizeOf(key, previous);
            }
        }

        if (previous != null) {
            entryRemoved(false, key, previous, value);
        }

        trimToSize(maxSize);
        return previous;
    }

    //检测缓存是否越界
    private void trimToSize(int maxSize) {
        while (true) {
            K key;
            V value;
            synchronized (this) {
                if (size < 0 || (map.isEmpty() && size != 0)) {
                    throw new IllegalStateException(getClass().getName()
                            + ".sizeOf() is reporting inconsistent results!");
                }
                //如果没有,则返回
                if (size <= maxSize) {
                    break;
                }
                //以下代码表示已经超出了最大范围
                Map.Entry<K, V> toEvict = null;
                for (Map.Entry<K, V> entry : map.entrySet()) {
                    toEvict = entry;
                }

                if (toEvict == null) {
                    break;
                }
                //移除最后一个,也就是最少使用的缓存
                key = toEvict.getKey();
                value = toEvict.getValue();
                map.remove(key);
                size -= safeSizeOf(key, value);
                evictionCount++;
            }

            entryRemoved(true, key, value, null);
        }
    }

    //手动移除,用户调用
    public final V remove(K key) {
        if (key == null) {
            throw new NullPointerException("key == null");
        }

        V previous;
        synchronized (this) {
            previous = map.remove(key);
            if (previous != null) {
                size -= safeSizeOf(key, previous);
            }
        }

        if (previous != null) {
            entryRemoved(false, key, previous, null);
        }

        return previous;
    }
    //这里用户可以重写它,实现数据和内存回收操作
    protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {}


    protected V create(K key) {
        return null;
    }

    private int safeSizeOf(K key, V value) {
        int result = sizeOf(key, value);
        if (result < 0) {
            throw new IllegalStateException("Negative size: " + key + "=" + value);
        }
        return result;
    }

        //这个方法要特别注意,跟我们实例化 LruCache 的 maxSize 要呼应,怎么做到呼应呢,比如 maxSize 的大小为缓存的个数,这里就是 return 1就 ok,如果是内存的大小,如果5M,这个就不能是个数 了,这是应该是每个缓存 value 的 size 大小,如果是 Bitmap,这应该是 bitmap.getByteCount();
    protected int sizeOf(K key, V value) {
        return 1;
    }

    //清空缓存
    public final void evictAll() {
        trimToSize(-1); // -1 will evict 0-sized elements
    }


    public synchronized final int size() {
        return size;
    }


    public synchronized final int maxSize() {
        return maxSize;
    }


    public synchronized final int hitCount() {
        return hitCount;
    }


    public synchronized final int missCount() {
        return missCount;
    }


    public synchronized final int createCount() {
        return createCount;
    }


    public synchronized final int putCount() {
        return putCount;
    }


    public synchronized final int evictionCount() {
        return evictionCount;
    }


    public synchronized final Map<K, V> snapshot() {
        return new LinkedHashMap<K, V>(map);
    }
}


0
0
查看评论
发表评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场

使用LRUCatche 做缓存方式

Android利用LruCache异步加载大量图片完整示例 MainActivity如下: package cc.testlrucache; import android.os.Bundle; ...
  • benhang
  • benhang
  • 2014-02-08 14:02
  • 1385

LRU cache 算法的实现

#什么是LRU LRU Cache是一个Cache置换算法,含义是“最近最少使用”,当Cache满(没有空闲的cache块)时,把满足“最近最少使用”的数据从Cache中置换出去,并且保证Cache中...
  • renwotao2009
  • renwotao2009
  • 2016-11-07 15:16
  • 1110

LRU算法四种实现方式介绍

LRU全称是Least Recently Used,即最近最久未使用的意思。 LRU算法的设计原则是:如果一个数据在最近一段时间没有被访问到,那么在将来它被访问的可能性也很小。也就是说,当限定的空间...
  • elricboa
  • elricboa
  • 2017-12-19 20:58
  • 97

Memcached之你真正理解LRU吗(4)

众所周知,Memcached使用的是LRU(Least Recently Used最近最少使用)算法来回收缓存,将那些属于LRU的数据移出内存,从而腾出空间来加载另外的数据。那么Memcached的最...
  • qianshangding0708
  • qianshangding0708
  • 2015-08-25 21:58
  • 4269

说说Android LRU缓存算法实现笔记(二)--LRU的应用

上一篇文章说说Android LRU缓存算法实现学习笔记(一) 中我们介绍了最常用的实现LRU缓存的数据结构LinkedHashMap,这一节我们会针对LinkedHashMap的数据结构的特性,来自...
  • Johnnyz1234
  • Johnnyz1234
  • 2015-02-26 23:30
  • 1788

深入理解Memcache原理

1.为什么要使用memcache  由于网站的高并发读写需求,传统的关系型数据库开始出现瓶颈,例如: 1)对数据库的高并发读写: 关系型数据库本身就是个庞然大物,处理过程非常耗时(如解析SQL语句,事...
  • wusuopuBUPT
  • wusuopuBUPT
  • 2014-01-13 23:46
  • 18596

Android高效加载图片和缓存策略LRU,DiskLRU

1.高效加载图片加载图片主要用到BitmapFactory类的四个方法:decodeFile()从文件中加载,decodeResource()从资源文件中加载,decodeStream()从输入流,d...
  • Houson_c
  • Houson_c
  • 2016-07-24 08:51
  • 626

Lru算法在Android中的应用

Lru算法,将命中率不高的空间释放掉,保留命中率较高的空间。
  • farsight2009
  • farsight2009
  • 2016-11-16 14:36
  • 312

LruCache 实现原理分析

LruCache 实现原理分析最近研究了一下LruCahce的实现原理,以前也看过几遍源码了,但是有些还是没有理解清楚。重新撸了一遍代码,吼吼吼。声明的变量 private final Link...
  • u012943767
  • u012943767
  • 2016-07-13 13:36
  • 3738

Android 显示原理简介

首先,用一句话来概括一下Android应用程序显示的过程:Android应用程序调用SurfaceFlinger服务把经过测量、布局和绘制后的Surface渲染到显示屏幕上。   名词解释...
  • dxpqxb
  • dxpqxb
  • 2016-11-17 20:21
  • 718
    个人资料
    • 访问:236863次
    • 积分:1800
    • 等级:
    • 排名:千里之外
    • 原创:21篇
    • 转载:5篇
    • 译文:0篇
    • 评论:20条
    最新评论