Android进阶之彻底理解LruCache缓存机制原理

移动开发 Android
Android的三级缓存,其中主要的就是内存缓存和硬盘缓存。这两种缓存机制的实现都应用到了LruCache算法,今天我们就从使用到源码解析,来彻底理解Android中的缓存机制。

[[421640]]

前言

Android的三级缓存,其中主要的就是内存缓存和硬盘缓存。这两种缓存机制的实现都应用到了LruCache算法,今天我们就从使用到源码解析,来彻底理解Android中的缓存机制;

一、LruCache概念介绍

1.什么是LruCache?

LruCache是Android 3.1所提供的一个缓存类,所以在Android中可以直接使用LruCache实现内存缓存。而DisLruCache目前在Android 还不是Android SDK的一部分,但Android官方文档推荐使用该算法来实现硬盘缓存;

LruCache是个泛型类,主要算法原理是把最近使用的对象用强引用(即我们平常使用的对象引用方式)存储在 LinkedHashMap 中。当缓存满时,把最近最少使用的对象从内存中移除,并提供了get和put方法来完成缓存的获取和添加操作;

2.LruCache的使用

LruCache的使用非常简单,我们就已图片缓存为例

  1. int maxMemory = (int) (Runtime.getRuntime().totalMemory()/1024); 
  2.         int cacheSize = maxMemory/8; 
  3.         mMemoryCache = new LruCache<String,Bitmap>(cacheSize){ 
  4.             @Override 
  5.             protected int sizeOf(String key, Bitmap value) { 
  6.                 return value.getRowBytes()*value.getHeight()/1024; 
  7.             } 
  8.         }; 

①设置LruCache缓存的大小,一般为当前进程可用容量的1/8;

②重写sizeOf方法,计算出要缓存的每张图片的大小;

注意:缓存的总容量和每个缓存对象的大小所用单位要一致;

二、LruCache的实现原理

LruCache的核心思想很好理解,就是要维护一个缓存对象列表,其中对象列表的排列方式是按照访问顺序实现的,即一直没访问的对象,将放在队尾,即将被淘汰。而最近访问的对象将放在队头,最后被淘汰;

1、构造函数

  1. public LruCache(int maxSize) { 
  2.         if (maxSize <= 0) { 
  3.             throw new IllegalArgumentException("maxSize <= 0"); 
  4.         } 
  5.         this.maxSize = maxSize; 
  6.         this.map = new LinkedHashMap<K, V>(0, 0.75f, true); 
  7.     } 

创建LruCache对象时,它内部做的工作如下:

  • 记录下制定的最大容量maxSize;
  • 创建一个初始容量为0的LinkedHashMap,用来保存对象;
  • 所以,在创建LruCache对象时,我们需要指定一个最大容量值maxSize,它可以是具体数值,也可以是内存空间,与它对应的是sizeOf方法:
  1. protected int sizeOf(K key, V value) { 
  2.       return 1; 
  3.   } 

如果我们想以数量的方式来控制缓存,可以看到,默认的sizeOf方法返回值为1,也就是说每次添加一条数据,它所占用的空间为1,直到添加的内容数量达到maxSize,这时候再添加数据,系统就会挑选出使用频率最低的值,将他们移除;

如果以内存空间作为缓存限制,需要重写size,返回对象所占用的空间大小:

  1. int maxMemory = (int) (Runtime.getRuntime().maxMemory())/1024;//获取可用内存,转换为单位KB 
  2.       int maxCache = maxMemory/10;//缓存大小为可用内存的1/10 
  3.       LruCache mMemoryCache = new LruCache<String,Bitmap>(maxCache){ 
  4.           @Override//重写sizeOf方法,返回每条数据占用的内存 
  5.           protected int sizeOf(String key, Bitmap value) { 
  6.               return value.getRowBytes()*value.getHeight() / 1024; 
  7.               //return value.getByteCount() / 1024; 
  8.           } 
  9.       }; 

2、读取内容

读取内容对应的是get方法,源码如下:

  1. public final V get(K key) { 
  2.         if (key == null) {     //如果keynull,直接抛出异常 
  3.             throw new NullPointerException("key == null"); 
  4.         } 
  5.         V mapValue; 
  6.         synchronized (this) { 
  7.             mapValue = map.get(key);  //读取key对应的值 
  8.             if (mapValue != null) { 
  9.                 hitCount++; 
  10.                 return mapValue;     //如果获取到内容,返回 
  11.             } 
  12.             missCount++;   //如果未读到内容,missCount计数增加,继续向下执行 
  13.         } 
  14.         /*尝试创建value,可能会消耗一定的时间,当创建完成时,map可能已经发生变化 
  15.           如果此时发现创建时使用的key已经存在,导致冲突,丢弃掉create创建的值 
  16.          * Attempt to create a value. This may take a long timeand the map 
  17.          * may be different when create() returns. If a conflicting value was 
  18.          * added to the map while create() was working, we leave that value in 
  19.          * the map and release the created value. 
  20.          */ 
  21.       //如果未获取到value,调用create方法,尝试创建对象 
  22.      //create方法默认返回null,可以覆写该方法,决定获取不到值时的添加方法 
  23.         V createdValue = create(key); 
  24.         if (createdValue == null) { 
  25.             return null
  26.         } 
  27.   //以下部分为创建之后对map的修改动作,包括存放对象,调整size等。 
  28.         synchronized (this) { 
  29.             createCount++; 
  30.             mapValue = map.put(key, createdValue); 
  31.             if (mapValue != null) { 
  32.                 // There was a conflict so undo that last put 
  33.                 map.put(key, mapValue); 
  34.             } else { 
  35.                 size += safeSizeOf(key, createdValue); 
  36.             } 
  37.         } 
  38.         if (mapValue != null) { 
  39.             entryRemoved(falsekey, createdValue, mapValue); 
  40.             return mapValue; 
  41.         } else { 
  42.             trimToSize(maxSize); 
  43.             return createdValue; 
  44.         } 
  45.     } 

get方法尝试根据传入的key来读取内容,如果读取不到,可以选择是否创建一个对象,如果选择创建对象,需要我们覆写create方法来返回要创建的对象,使用也很简单;

3、存储内容

存储内容使用的是put方法:

  1. public final V put(K key, V value) { 
  2.         if (key == null || value == null) { 
  3.             throw new NullPointerException("key == null || value == null"); 
  4.         } 
  5.         V previous; 
  6.         synchronized (this) { 
  7.             putCount++; 
  8.             size += safeSizeOf(key, value); 
  9.             previous = map.put(key, value); 
  10.             if (previous != null) { 
  11.                 size -= safeSizeOf(key, previous); 
  12.             } 
  13.         } 
  14.         if (previous != null) { 
  15.             entryRemoved(falsekey, previous, value); 
  16.         } 
  17.         trimToSize(maxSize); 
  18.         return previous; 
  19.     } 

在存放内容的时候,可以看到是怎样控制缓存size的:存放内容之后会将执行size += safeSizeOf(key, value);,safeSizeOf的默认实现就是sizeOf方法。每存放一个对象,就会将size增加对应的值。如果存放的key已经存在数据,那么size不变;

同时还提供了一个entryRemoved方法,该方法在数据被移除时(调用remove移除,新值覆盖,超出缓存被删除)调用,默认实现为空;

在put的最后则是调用了trimToSize,这是控制缓存大小的方法,每当有新的数据存入时,该方法都会被调用。当前size超出缓存最大值之后,会通过此方法删除最近最少使用的数据;

除了正常的存储,读取之外,LruCache还提供了一个一次性读取全部缓存对象的方法:

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

4、trimToSize()方法

  1. public void trimToSize(int maxSize) { 
  2.         //死循环 
  3.         while (true) { 
  4.             K key
  5.             V value; 
  6.             synchronized (this) { 
  7.                 //如果map为空并且缓存size不等于0或者缓存size小于0,抛出异常 
  8.                 if (size < 0 || (map.isEmpty() && size != 0)) { 
  9.                     throw new IllegalStateException(getClass().getName() 
  10.                             + ".sizeOf() is reporting inconsistent results!"); 
  11.                 } 
  12.                 //如果缓存大小size小于最大缓存,或者map为空,不需要再删除缓存对象,跳出循环 
  13.                 if (size <= maxSize || map.isEmpty()) { 
  14.                     break; 
  15.                 } 
  16.                 //迭代器获取第一个对象,即队尾的元素,近期最少访问的元素 
  17.                 Map.Entry<K, V> toEvict = map.entrySet().iterator().next(); 
  18.                 key = toEvict.getKey(); 
  19.                 value = toEvict.getValue(); 
  20.                 //删除该对象,并更新缓存大小 
  21.                 map.remove(key); 
  22.                 size -= safeSizeOf(key, value); 
  23.                 evictionCount++; 
  24.             } 
  25.             entryRemoved(truekey, value, null); 
  26.         } 
  27.     } 

总结

LruCache中维护了一个集合LinkedHashMap,该LinkedHashMap是以访问顺序排序的。当调用put()方法时,就会在结合中添加元素,并调用trimToSize()判断缓存是否已满,如果满了就用LinkedHashMap的迭代器删除队尾元素,即近期最少访问的元素。当调用get()方法访问缓存对象时,就会调用LinkedHashMap的get()方法获得对应集合元素,同时会更新该元素到队头;

 

责任编辑:武晓燕 来源: Android开发编程
相关推荐

2021-09-14 07:06:12

Android磁盘缓存

2021-09-01 06:48:16

AndroidGlide缓存

2021-10-15 09:19:17

AndroidSharedPrefe分析源码

2023-11-16 08:22:14

LruCacheAndroid

2021-08-15 08:11:54

AndroidSynchronize关键字

2021-09-09 06:55:43

AndroidViewDragHel原理

2021-09-10 07:31:54

AndroidAppStartup原理

2018-11-30 09:03:55

HTTP缓存Web

2021-09-08 06:51:52

AndroidRetrofit原理

2021-09-16 06:44:04

Android进阶流程

2021-05-10 07:08:41

数据结构缓存

2021-09-30 07:36:51

AndroidViewDraw

2021-09-17 06:55:50

AndroidLayoutView

2021-09-15 07:31:33

Android窗口管理

2021-09-06 13:12:05

前端JavaScript编程

2021-09-24 08:10:40

Java 语言 Java 基础

2021-05-13 08:55:33

Android架构功能

2024-06-21 08:32:24

2022-10-24 08:08:27

闭包编译器

2021-09-18 06:56:01

JavaCAS机制
点赞
收藏

51CTO技术栈公众号