[[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的使用非常簡單，我們就已圖片緩存為例

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的核心思想很好理解，就是要維護一個緩存對象列表，其中對象列表的排列方式是按照訪問順序實現的，即一直沒訪問的對象，將放在隊尾，即將被淘汰。而最近訪問的對象將放在隊頭，最后被淘汰;

1、構造函數

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對象時，它內部做的工作如下：

• 記錄下制定的最大容量maxSize;
• 創建一個初始容量為0的LinkedHashMap，用來保存對象;
• 所以，在創建LruCache對象時，我們需要指定一個最大容量值maxSize，它可以是具體數值，也可以是內存空間，與它對應的是sizeOf方法：

protected int sizeOf(K key, V value) { 
      return 1; 
  } 

如果我們想以數量的方式來控制緩存，可以看到，默認的sizeOf方法返回值為1，也就是說每次添加一條數據，它所占用的空間為1，直到添加的內容數量達到maxSize，這時候再添加數據，系統就會挑選出使用頻率最低的值，將他們移除;

如果以內存空間作為緩存限制，需要重寫size，返回對象所占用的空間大小:

int maxMemory = (int) (Runtime.getRuntime().maxMemory())/1024;//獲取可用內存，轉換為單位KB 
      int maxCache = maxMemory/10;//緩存大小為可用內存的1/10 
      LruCache mMemoryCache = new LruCache<String,Bitmap>(maxCache){ 
          @Override//重寫sizeOf方法，返回每條數據占用的內存 
          protected int sizeOf(String key, Bitmap value) { 
              return value.getRowBytes()*value.getHeight() / 1024; 
              //return value.getByteCount() / 1024; 
          } 
      }; 

2、讀取內容

讀取內容對應的是get方法，源碼如下：

public final V get(K key) { 
        if (key == null) {     //如果key為null，直接拋出異常 
            throw new NullPointerException("key == null"); 
        } 
        V mapValue; 
        synchronized (this) { 
            mapValue = map.get(key);  //讀取key對應的值 
            if (mapValue != null) { 
                hitCount++; 
                return mapValue;     //如果獲取到內容，返回 
            } 
            missCount++;   //如果未讀到內容，missCount計數增加，繼續向下執行 
        } 
        /*嘗試創建value，可能會消耗一定的時間，當創建完成時，map可能已經發生變化 
          如果此時發現創建時使用的key已經存在，導致沖突，丟棄掉create創建的值 
         * 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. 
         */ 
      //如果未獲取到value，調用create方法，嘗試創建對象 
     //create方法默認返回null，可以覆寫該方法，決定獲取不到值時的添加方法 
        V createdValue = create(key); 
        if (createdValue == null) { 
            return null; 
        } 
  //以下部分為創建之后對map的修改動作，包括存放對象，調整size等。 
        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; 
        } 
    } 

get方法嘗試根據傳入的key來讀取內容，如果讀取不到，可以選擇是否創建一個對象，如果選擇創建對象，需要我們覆寫create方法來返回要創建的對象，使用也很簡單;

3、存儲內容

存儲內容使用的是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; 
    } 

在存放內容的時候，可以看到是怎樣控制緩存size的：存放內容之后會將執行size += safeSizeOf(key, value);，safeSizeOf的默認實現就是sizeOf方法。每存放一個對象，就會將size增加對應的值。如果存放的key已經存在數據，那么size不變;

同時還提供了一個entryRemoved方法，該方法在數據被移除時(調用remove移除，新值覆蓋，超出緩存被刪除)調用，默認實現為空;

在put的最后則是調用了trimToSize，這是控制緩存大小的方法，每當有新的數據存入時，該方法都會被調用。當前size超出緩存最大值之后，會通過此方法刪除最近最少使用的數據;

除了正常的存儲，讀取之外，LruCache還提供了一個一次性讀取全部緩存對象的方法：

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

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

總結

LruCache中維護了一個集合LinkedHashMap，該LinkedHashMap是以訪問順序排序的。當調用put()方法時，就會在結合中添加元素，并調用trimToSize()判斷緩存是否已滿，如果滿了就用LinkedHashMap的迭代器刪除隊尾元素，即近期最少訪問的元素。當調用get()方法訪問緩存對象時，就會調用LinkedHashMap的get()方法獲得對應集合元素，同時會更新該元素到隊頭;