1. 程式人生 > >徹底解析Android快取機制——LruCache

徹底解析Android快取機制——LruCache

轉:

關於Android的三級快取,其中主要的就是記憶體快取和硬碟快取。這兩種快取機制的實現都應用到了LruCache演算法,今天我們就從使用到原始碼解析,來徹底理解Android中的快取機制。

一、Android中的快取策略

一般來說,快取策略主要包含快取的新增、獲取和刪除這三類操作。如何新增和獲取快取這個比較好理解,那麼為什麼還要刪除快取呢?這是因為不管是記憶體快取還是硬碟快取,它們的快取大小都是有限的。當快取滿了之後,再想其新增快取,這個時候就需要刪除一些舊的快取並新增新的快取。

因此LRU(Least Recently Used)快取演算法便應運而生,LRU是近期最少使用的演算法,它的核心思想是當快取滿時,會優先淘汰那些近期最少使用的快取物件。採用LRU演算法的快取有兩種:LrhCache和DisLruCache,分別用於實現記憶體快取和硬碟快取,其核心思想都是LRU快取演算法。

二、LruCache的使用

LruCache是Android 3.1所提供的一個快取類,所以在Android中可以直接使用LruCache實現記憶體快取。而DisLruCache目前在Android 還不是Android SDK的一部分,但Android官方文件推薦使用該演算法來實現硬碟快取。

1.LruCache的介紹

LruCache是個泛型類,主要演算法原理是把最近使用的物件用強引用(即我們平常使用的物件引用方式)儲存在 LinkedHashMap 中。當快取滿時,把最近最少使用的物件從記憶體中移除,並提供了get和put方法來完成快取的獲取和新增操作。

2.LruCache的使用

LruCache的使用非常簡單,我們就已圖片快取為例。

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

①設定LruCache快取的大小,一般為當前程序可用容量的1/8。
②重寫sizeOf方法,計算出要快取的每張圖片的大小。

注意:快取的總容量和每個快取物件的大小所用單位要一致。

三、LruCache的實現原理

LruCache的核心思想很好理解,就是要維護一個快取物件列表,其中物件列表的排列方式是按照訪問順序實現的,即一直沒訪問的物件,將放在隊尾,即將被淘汰。而最近訪問的物件將放在隊頭,最後被淘汰。

如下圖所示:



那麼這個佇列到底是由誰來維護的,前面已經介紹了是由LinkedHashMap來維護。

而LinkedHashMap是由陣列+雙向連結串列的資料結構來實現的。其中雙向連結串列的結構可以實現訪問順序和插入順序,使得LinkedHashMap中的<key,value>對按照一定順序排列起來。

通過下面建構函式來指定LinkedHashMap中雙向連結串列的結構是訪問順序還是插入順序。

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

其中accessOrder設定為true則為訪問順序,為false,則為插入順序。

以具體例子解釋:
當設定為true時

public static final void main(String[] args) {
        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.put(4, 4);
        map.put(5, 5);
        map.put(6, 6);
        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
4:4
5:5
6:6
1:1
2:2

即最近訪問的最後輸出,那麼這就正好滿足的LRU快取演算法的思想。可見LruCache巧妙實現,就是利用了LinkedHashMap的這種資料結構。

下面我們在LruCache原始碼中具體看看,怎麼應用LinkedHashMap來實現快取的新增,獲得和刪除的。

 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);
    }

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

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) {
            //插入的快取物件值加1
            putCount++;
            //增加已有快取的大小
            size += safeSizeOf(key, value);
           //向map中加入快取物件
            previous = map.put(key, value);
            //如果已有快取物件,則快取大小恢復到之前
            if (previous != null) {
                size -= safeSizeOf(key, previous);
            }
        }
        //entryRemoved()是個空方法,可以自行實現
        if (previous != null) {
            entryRemoved(false, key, previous, value);
        }
        //調整快取大小(關鍵方法)
        trimToSize(maxSize);
        return previous;
    }

可以看到put()方法並沒有什麼難點,重要的就是在新增過快取物件後,呼叫 trimToSize()方法,來判斷快取是否已滿,如果滿了就要刪除近期最少使用的演算法。
trimToSize()方法

 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 || map.isEmpty()) {
                    break;
                }
                //迭代器獲取第一個物件,即隊尾的元素,近期最少訪問的元素
                Map.Entry<K, V> toEvict = map.entrySet().iterator().next();
                key = toEvict.getKey();
                value = toEvict.getValue();
                //刪除該物件,並更新快取大小
                map.remove(key);
                size -= safeSizeOf(key, value);
                evictionCount++;
            }
            entryRemoved(true, key, value, null);
        }
    }

trimToSize()方法不斷地刪除LinkedHashMap中隊尾的元素,即近期最少訪問的,直到快取大小小於最大值。

當呼叫LruCache的get()方法獲取集合中的快取物件時,就代表訪問了一次該元素,將會更新佇列,保持整個佇列是按照訪問順序排序。這個更新過程就是在LinkedHashMap中的get()方法中完成的。

先看LruCache的get()方法

get()方法

public final V get(K key) {
        //key為空丟擲異常
        if (key == null) {
            throw new NullPointerException("key == null");
        }

        V mapValue;
        synchronized (this) {
            //獲取對應的快取物件
            //get()方法會實現將訪問的元素更新到佇列頭部的功能
            mapValue = map.get(key);
            if (mapValue != null) {
                hitCount++;
                return mapValue;
            }
            missCount++;
        }

其中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;
    }

呼叫recordAccess()方法如下:

 void recordAccess(HashMap<K,V> m) {
            LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
            //判斷是否是訪問排序
            if (lm.accessOrder) {
                lm.modCount++;
                //刪除此元素
                remove();
                //將此元素移動到佇列的頭部
                addBefore(lm.header);
            }
        }

由此可見LruCache中維護了一個集合LinkedHashMap,該LinkedHashMap是以訪問順序排序的。當呼叫put()方法時,就會在結合中新增元素,並呼叫trimToSize()判斷快取是否已滿,如果滿了就用LinkedHashMap的迭代器刪除隊尾元素,即近期最少訪問的元素。當呼叫get()方法訪問快取物件時,就會呼叫LinkedHashMap的get()方法獲得對應集合元素,同時會更新該元素到隊頭。

以上便是LruCache實現的原理,理解了LinkedHashMap的資料結構就能理解整個原理。如果不懂,可以先看看LinkedHashMap的具體實現。