Android原始碼解析之（七）-->LruCache快取類
阿新 • • 發佈：2019-01-09
android開發過程中經常會用到快取，現在主流的app中圖片等資源的快取策略一般是分兩級，一個是記憶體級別的快取，一個是磁碟級別的快取。
作為android系統的維護者google也開源了其快取方案，LruCache和DiskLruCache。從android3.1開始LruCache已經作為android原始碼的一部分維護在android系統中，為了相容以前的版本android的support-v4包也提供了LruCache的維護，如果App需要相容到android3.1之前的版本就需要使用support-v4包中的LruCache，如果不需要相容到android3.1則直接使用android原始碼中的LruCache即可，這裡需要注意的是DiskLruCache並不是android原始碼的一部分。
在LruCache的原始碼中，關於LruCache有這樣的一段介紹：
A cache that holds strong references to a limited number of values. Each time a value is accessed, it is moved to the head of a queue. When a value is added to a full cache, the value at the end of that queue is evicted and may become eligible for garbage collection cache物件通過一個強引用來訪問內容。每次當一個item被訪問到的時候，這個item就會被移動到一個佇列的隊首。當一個item被新增到已經滿了的佇列時，這個佇列的隊尾的item就會被移除。
其實這個實現的過程就是LruCache的快取策略，即Lru–>(Least recent used)最少最近使用演算法。
下面我們具體看一下LruCache的實現：
public class LruCache<K, V> {
private final LinkedHashMap<K, V> map;
/** Size of this cache in units. Not necessarily the number of elements. */ 可以看到LruCache初始化的時候需要使用泛型，一般的我們這樣初始化LruCache物件：
// 獲取應用程式最大可用記憶體
int maxMemory = (int) Runtime.getRuntime().maxMemory();
int cacheSize = maxMemory / 8;
// 設定圖片快取大小為程式最大可用記憶體的1/8
mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
@Override
protected int sizeOf(String key, Bitmap bitmap) {
return bitmap.getByteCount();
}
}; 這裡我們假設通過String作為key儲存bitmap物件，同時需要傳遞一個int型的maxSize數值，主要用於設定LruCache連結串列的最大值。
檢視其構造方法：
// 獲取應用程式最大可用記憶體
int maxMemory = (int) Runtime.getRuntime().maxMemory();
int cacheSize = maxMemory / 8;
// 設定圖片快取大小為程式最大可用記憶體的1/8
mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
@Override
protected int sizeOf(String key, Bitmap bitmap) {
return bitmap.getByteCount();
}
}; 可以看到其主要的是初始化了maxSize和map連結串列物件。
然後檢視put方法：
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;
}需要傳遞兩個引數：K和V，首先做了一下引數的判斷，然後定義一個儲存前一個Value值得臨時變數，讓putCount（put執行的次數）自增，讓map的size大小自增。
需要注意的是這裡的
previous = map.put(key, value);我們看一下這裡的map.put（）的具體實現：
@Override public V put(K key, V value) {
if (key == null) {
return putValueForNullKey(value);
}
int hash = Collections.secondaryHash(key);
HashMapEntry<K, V>[] tab = table;
int index = hash & (tab.length - 1);
for (HashMapEntry<K, V> e = tab[index]; e != null; e = e.next) {
if (e.hash == hash && key.equals(e.key)) {
preModify(e);
V oldValue = e.value;
e.value = value;
return oldValue;
}
}
// No entry for (non-null) key is present; create one
modCount++;
if (size++ > threshold) {
tab = doubleCapacity();
index = hash & (tab.length - 1);
}
addNewEntry(key, value, hash, index);
return null;
}將Key與Value的值壓入Map中，這裡判斷了一下如果map中已經存在該key，value鍵值對，則不再壓入map，並將Value值返回，否則將該鍵值對壓入Map中，並返回null；
返回繼續put方法：
previous = map.put(key, value);
if (previous != null) {
size -= safeSizeOf(key, previous);
}可以看到這裡我們判斷map.put方法的返回值是否為空，如果不為空的話，則說明我們剛剛並沒有將我麼你的鍵值對壓入Map中，所以這裡的size需要自減；
然後下面：
if (previous != null) {
entryRemoved(false, key, previous, value);
}這裡判斷previous是否為空，如果不為空的話，呼叫了一個空的實現方法entryRemoved()，也就是說我們可以實現自己的LruCache並在新增快取的時候若存在該快取可以重寫這個方法；
下面呼叫了trimToSize(maxSize)方法：
public 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 = 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);
}
}該方法主要是判斷該Map的大小是否已經達到闕值，若達到，則將Map隊尾的元素（最不常使用的元素）remove掉。
總結：
LruCache put方法，將鍵值對壓入Map資料結構中，若這是Map的大小已經大於LruCache中定義的最大值，則將Map中最早壓入的元素remove掉；
檢視get方法：
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++;
}
/*
* Attempt to create a value. This may take a long time, and the map
* may be different when create() returns. If a conflicting value was
* added to the map while create() was working, we leave that value in
* the map and release the created value.
*/
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;
}
}可以看到引數值為Key，簡單的理解就是通過key值從map中取出Value值。
具體來說，判斷map中是否含有key值value值，若存在，則hitCount（擊中元素數量）自增，並返回Value值，若沒有擊中，則執行create(key)方法，這裡看到create方法是一個空的實現方法，返回值為null，所以我們可以重寫該方法，在呼叫get（key）的時候若沒有找到value值，則自動建立一個value值並壓入map中。
總結：
LruCache，內部使用Map儲存記憶體級別的快取
LruCache使用泛型可以設配各種型別
LruCache使用了Lru演算法儲存資料（最短最少使用least recent use）
LruCache只用使用put和get方法壓入資料和取出資料