[[421640]]

前言

Android的三級緩存，其中主要的就是內(nèi)存緩存和硬盤緩存。這兩種緩存機制的實現(xiàn)都應(yīng)用到了LruCache算法，今天我們就從使用到源碼解析，來徹底理解Android中的緩存機制;

一、LruCache概念介紹

1.什么是LruCache?

LruCache是Android 3.1所提供的一個緩存類，所以在Android中可以直接使用LruCache實現(xiàn)內(nèi)存緩存。而DisLruCache目前在Android 還不是Android SDK的一部分，但Android官方文檔推薦使用該算法來實現(xiàn)硬盤緩存;

LruCache是個泛型類，主要算法原理是把最近使用的對象用強引用(即我們平常使用的對象引用方式)存儲在 LinkedHashMap 中。當(dāng)緩存滿時，把最近最少使用的對象從內(nèi)存中移除，并提供了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; 
            } 
        }; 

①設(shè)置LruCache緩存的大小，一般為當(dāng)前進程可用容量的1/8;

②重寫sizeOf方法，計算出要緩存的每張圖片的大小;

注意：緩存的總?cè)萘亢兔總€緩存對象的大小所用單位要一致;

二、LruCache的實現(xiàn)原理

LruCache的核心思想很好理解，就是要維護一個緩存對象列表，其中對象列表的排列方式是按照訪問順序?qū)崿F(xiàn)的，即一直沒訪問的對象，將放在隊尾，即將被淘汰。而最近訪問的對象將放在隊頭，最后被淘汰;

1、構(gòu)造函數(shù)

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

創(chuàng)建LruCache對象時，它內(nèi)部做的工作如下：

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

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

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

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

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

2、讀取內(nèi)容

讀取內(nèi)容對應(yīng)的是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對應(yīng)的值 
            if (mapValue != null) { 
                hitCount++; 
                return mapValue;     //如果獲取到內(nèi)容，返回 
            } 
            missCount++;   //如果未讀到內(nèi)容，missCount計數(shù)增加，繼續(xù)向下執(zhí)行 
        } 
        /*嘗試創(chuàng)建value，可能會消耗一定的時間，當(dāng)創(chuàng)建完成時，map可能已經(jīng)發(fā)生變化 
          如果此時發(fā)現(xiàn)創(chuàng)建時使用的key已經(jīng)存在，導(dǎo)致沖突，丟棄掉create創(chuàng)建的值 
         * 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，調(diào)用create方法，嘗試創(chuàng)建對象 
     //create方法默認(rèn)返回null，可以覆寫該方法，決定獲取不到值時的添加方法 
        V createdValue = create(key); 
        if (createdValue == null) { 
            return null; 
        } 
  //以下部分為創(chuàng)建之后對map的修改動作，包括存放對象，調(diào)整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方法嘗試根據(jù)傳入的key來讀取內(nèi)容，如果讀取不到，可以選擇是否創(chuàng)建一個對象，如果選擇創(chuàng)建對象，需要我們覆寫create方法來返回要創(chuàng)建的對象，使用也很簡單;

3、存儲內(nèi)容

存儲內(nèi)容使用的是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; 
    } 

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

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

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

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

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

4、trimToSize()方法

public void trimToSize(int maxSize) { 
        //死循環(huán) 
        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為空，不需要再刪除緩存對象，跳出循環(huán) 
                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); 
        } 
    } 

總結(jié)

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