Android緩存機制——LruCache的詳解

這篇文章主要介紹了Android緩存機制LruCache，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨着小編來一起學習學習吧

概述

LruCache的核心原理就是對LinkedHashMap的有效利用，它的內部存在一個LinkedHashMap成員變量，值得注意的4個方法：構造方法、get、put、trimToSize

LRU(Least Recently Used)緩存算法便應運而生，LRU是最近最少使用的算法，它的核心思想是當緩存滿時，會優先淘汰那些最近最少使用的緩存對象。採用LRU算法的緩存有兩種：LrhCache和DisLruCache，分別用於實現內存緩存和硬盤緩存，其核心思想都是LRU緩存算法。

LRU原理

LruCache的核心思想很好理解，就是要維護一個緩存對象列表，其中對象列表的排列方式是按照訪問順序實現的，即一直沒訪問的對象，將放在隊頭，即將被淘汰。而最近訪問的對象將放在隊尾，最後被淘汰。（隊尾添加元素，隊頭刪除元素）

LruCache 其實使用了 LinkedHashMap 雙向鏈表結構，現在分析下 LinkedHashMap 使用方法。

1.構造方法：

public LinkedHashMap(int initialCapacity,
 float loadFactor,
 boolean accessOrder) {
 super(initialCapacity, loadFactor);
 this.accessOrder = accessOrder;
}

當 accessOrder 爲 true 時，這個集合的元素順序就會是訪問順序，也就是訪問了之後就會將這個元素放到集合的最後面。

例如：

LinkedHashMap < Integer, Integer > map = new LinkedHashMap < > (0, 0.75f, true);
map.put(0, 0);
map.put(1, 1);
map.put(2, 2);
map.put(3, 3);
map.get(1);
map.get(2);

for (Map.Entry < Integer, Integer > entry: map.entrySet()) {
 System.out.println(entry.getKey() + ":" + entry.getValue());

}

輸出結果：

0:0
3:3
1:1
2:2

下面我們在LruCache源碼中具體看看，怎麼應用LinkedHashMap來實現緩存的添加，獲得和刪除的：

/**
  * @param maxSize for caches that do not override {@link #sizeOf}, this is
  *  the maximum number of entries in the cache. For all other caches,
  *  this is the maximum sum of the sizes of the entries in this cache.
  */
 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);//accessOrder被設置爲true
 }

從LruCache的構造函數中可以看到正是用了LinkedHashMap的訪問順序。

2.put()方法

/**
  * Caches {@code value} for {@code key}. The value is moved to the head of
  * the queue.
  *
  * @return the previous value mapped by {@code key}.
  */
 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++;//插入緩存對象加1
   size += safeSizeOf(key, value);//增加已有緩存的大小
   previous = map.put(key, value);//向map中加入緩存對象
   if (previous != null) {//如果已有緩存對象，則緩存大小恢復到之前
    size -= safeSizeOf(key, previous);
   }
  }

  if (previous != null) {//entryRemoved()是個空方法，可以自行實現
   entryRemoved(false, key, previous, value);
  }

  trimToSize(maxSize);//調整緩存大小(關鍵方法)
  return previous;
 }

可以看到put()方法重要的就是在添加過緩存對象後，調用 trimToSize()方法來保證內存不超過maxSize

3.trimToSize方法

再看一下trimToSize()方法：

/**
  * Remove the eldest entries until the total of remaining entries is at or
  * below the requested size.
  *
  * @param maxSize the maximum size of the cache before returning. May be -1
  *   to evict even 0-sized elements.
  */
 public void trimToSize(int maxSize) {
  while (true) {//死循環
   K key;
   V value;
   synchronized (this) {
　　　　　　　　 //如果map爲空並且緩存size不等於0或者緩存size小於0，拋出異常
    if (size < 0 || (map.isEmpty() && size != 0)) {
     throw new IllegalStateException(getClass().getName()
       + ".sizeOf() is reporting inconsistent results!");
    }
　　　　　　　　　　//如果緩存大小size小於最大緩存，或者map爲空，不需要再刪除緩存對象，跳出循環
    if (size <= maxSize) {
     break;
    }
　　　　　　　　　　// 取出 map 中最老的映射
    Map.Entry<K, V> toEvict = map.eldest();
    if (toEvict == null) {
     break;
    }

    key = toEvict.getKey();
    value = toEvict.getValue();
    map.remove(key);
    size -= safeSizeOf(key, value);
    evictionCount++;
   }

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

trimToSize()方法不斷地刪除LinkedHashMap中隊頭的元素，即近期最少訪問的，直到緩存大小小於最大值。

4. get方法

當調用LruCache的get()方法獲取集合中的緩存對象時，就代表訪問了一次該元素，將會更新隊列，保持整個隊列是按照訪問順序排序。這個更新過程就是在LinkedHashMap中的get()方法中完成的。

接着看LruCache的get()方法

/**
  * Returns the value for {@code key} if it exists in the cache or can be
  * created by {@code #create}. If a value was returned, it is moved to the
  * head of the queue. This returns null if a value is not cached and cannot
  * be created.
  */
 public final V get(K key) {
  if (key == null) {//key不能爲空
   throw new NullPointerException("key == null");
  }

  V mapValue;
  synchronized (this) {
　　　　　　　　/獲取對應的緩存對象 
   mapValue = map.get(key);
   if (mapValue != null) {
    hitCount++;
    return mapValue;
   }
   missCount++;
  }

看到LruCache的get方法實際是調用了LinkedHashMap的get方法：

public V get(Object key) {
  LinkedHashMapEntry<K,V> e = (LinkedHashMapEntry<K,V>)getEntry(key);
  if (e == null)
   return null;
  e.recordAccess(this);//實現排序的關鍵
  return e.value;
 }

再接着看LinkedHashMapEntry的recordAccess方法：

/**
   * This method is invoked by the superclass whenever the value
   * of a pre-existing entry is read by Map.get or modified by Map.set.
   * If the enclosing Map is access-ordered, it moves the entry
   * to the end of the list; otherwise, it does nothing.
   */
  void recordAccess(HashMap<K,V> m) {
   LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
   if (lm.accessOrder) {//判斷是否是訪問順序
    lm.modCount++;
    remove();//刪除此元素
    addBefore(lm.header);//將此元素移到隊尾
   }
  }

recordAccess方法的作用是如果accessOrder爲true，把已存在的entry在調用get讀取或者set編輯後移到隊尾，否則不做任何操作。

也就是說： 這個方法的作用就是將剛訪問過的元素放到集合的最後一位

總結：

LruCache的核心原理就是對LinkedHashMap 對象的有效利用。在構造方法中設置maxSize並將accessOrder設爲true，執行get後會將訪問元素放到隊列尾，put操作後則會調用trimToSize維護LinkedHashMap的大小不大於maxSize。

以上所述是小編給大家介紹的Android緩存機制LruCache詳解整合，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回覆大家的。在此也非常感謝大家對神馬文庫網站的支持！