介紹

oom異常：大圖片導致
圖片的三級快取：記憶體、磁碟、網路
下面通過一張圖來了解下三級快取原理：

程式碼：

public class Davince {
    //使用固定執行緒池優化 
    private static  ExecutorService threadPool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);
    private static final String TAG = "Davince";
    private static Davince sInstance = new
 
 Davince();
    public static Context sContext;
    public static Davince with(Context context) {
        //執行緒池多少個執行緒：有當前的裝置的cpu核數決定
        sContext = context;
        return sInstance;
    }

    public Requestor load(String url) {
        return new Requestor(url);
    }

    //給 LruCache分配最大的使用記憶體
    //使用lru快取必須重寫sizeOf方法
 

    public static LruCache<String, Bitmap> mCaches = new LruCache<String, Bitmap>((int) (Runtime.getRuntime().maxMemory() / 3)) {

        @Override
        protected int sizeOf(String key, Bitmap value) {
            //快取當前要存放的Bitmap的大小
            return value.getByteCount();
        }
    };

    //圖片的記憶體快取 以前的快取方式，現在不用
 

    //private Map<String, SoftReference<Bitmap>> mCaches = new HashMap<String, SoftReference<Bitmap>>();

    public static final Handler sHandler = new Handler(Looper.getMainLooper());
    //載入圖片的類
    public class Requestor {

        private String mUrl;
        public Requestor(String mUrl) {
            this.mUrl = mUrl;
        }

        private int mErrorResId;
        public Requestor error(int errorResId) {
            this.mErrorResId = errorResId;
            return this;
        }

        //載入圖片：三級快取
        public void into(ImageView target) {
            //從記憶體載入圖片：設計記憶體快取
            //Bitmap bitmap = mCaches.get(mUrl);

            //從Lru獲取
            Bitmap bitmap = mCaches.get(mUrl);

            //從軟引用獲取 捨棄不用
//            SoftReference<Bitmap> reference = mCaches.get(mUrl);
//            if (reference!=null) {
//
//                bitmap = reference.get();
//            }

            //記憶體有圖片
            if (bitmap != null) {

                Log.i(TAG, "從記憶體獲取");
                target.setImageBitmap(bitmap);
                return;
            }

            //記憶體沒有圖片，從disk獲取
            bitmap = getBitmapFromDisk(mUrl);

            //磁碟有圖片：
            if (bitmap != null) {

                Log.i(TAG, "從磁盤獲取");
                //存放到記憶體
                //存放到Lru快取
                mCaches.put(mUrl, bitmap);

                //mCaches.put(mUrl, bitmap);
//                //存放到軟引用 捨棄不用
//                mCaches.put(mUrl, new SoftReference<Bitmap>(bitmap));

                //顯示圖片
                target.setImageBitmap(bitmap); 
                return;
            }

            //磁碟沒有圖片，從網路獲取

            //每次new Thread效能消耗會很大
            //new Thread(new LoadBitmapTask(mUrl, target, mErrorResId)).start();
            //從執行緒池中 開啟執行緒 
            threadPool.execute(new LoadBitmapTask(mUrl, target, mErrorResId));
        }
    }

    /*
        載入的圖片的任務
     */
    public class LoadBitmapTask implements Runnable {

        private String mUrl;
        private ImageView mImageView;
        private int mErrorResId;
        private Bitmap bitmap;

        public LoadBitmapTask(String mUrl, ImageView mImageView, int mErrorResId) {
            this.mUrl = mUrl;
            this.mImageView = mImageView;
            this.mErrorResId = mErrorResId;
        }

        @Override
        public void run() {

            //從網路載入圖片
            try {
                URLConnection urlConnection = new URL(mUrl).openConnection();
                urlConnection.setReadTimeout(5000);
                urlConnection.setConnectTimeout(5000);
                urlConnection.connect();
                //獲取到的圖片
                InputStream inputStream = urlConnection.getInputStream();
                bitmap = BitmapFactory.decodeStream(inputStream);

                //從網路載入成功
                //存放到磁碟
                saveBitmapToDisk(mUrl, bitmap);

                Log.i(TAG, "從網路獲取");

                //儲存的記憶體

                //存放到Lru快取
                mCaches.put(mUrl, bitmap);
                //mCaches.put(mUrl, bitmap);
//                //存放到軟引用 捨棄不用
//                mCaches.put(mUrl, new SoftReference<Bitmap>(bitmap));

                //顯示圖片 跳轉主執行緒顯示
                sHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        mImageView.setImageBitmap(bitmap);
                    }
                });

            } catch (Exception e) {
                e.printStackTrace();
                //出錯了，載入錯誤的圖片
                sHandler.post(new Runnable() {
                    @Override
                    public void run() {

                        mImageView.setImageResource(mErrorResId);
                    }
                });

            }
        }
    }

    private void saveBitmapToDisk(String mUrl, Bitmap bitmap) {

        try {
            //檔案路徑加MD5加密檔名
            File file = new File(getMyCacheDir(), MD5Utils.encode(mUrl));
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            //包Bitmap儲存到檔案
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fileOutputStream);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

    }

    private File getMyCacheDir() {

        //獲取apk: data/data/包民/cache
        File dir = new File(sContext.getCacheDir(), "davince-cache");
        if (!dir.exists()) {

            dir.mkdirs();
        }

        return dir;
    }
    //從磁盤獲取圖片
    private Bitmap getBitmapFromDisk(String mUrl) {
        File file = new File(getMyCacheDir(), MD5Utils.encode(mUrl));
        return BitmapFactory.decodeFile(file.getAbsolutePath());
    }
}

曾經，在各大快取圖片的框架沒流行的時候。有一種很常用的記憶體快取技術：SoftReference 和 WeakReference（軟引用和弱引用）。
但是走到了 Android 2.3（Level 9）時代，垃圾回收機制更傾向於回收 SoftReference 或 WeakReference 的物件。後來，
又來到了 Android3.0，圖片快取在內容中，因為不知道要在是什麼時候釋放記憶體，沒有策略，沒用一種可以預見的場合去將其釋放。這就造成了記憶體溢位。
優化點：

1.用執行緒池去管理執行緒，不用每次都去new 一個執行緒
2.Bitmap的快取優化：Bitmap佔用記憶體很大，如果不能被即時的回收就會oom
強引用：
軟引用：SoftReference, 用軟引用包裹Bitmap物件，當記憶體不足的時候就算Bitmap有引用也會回收Bitmap
弱引用：WeakReference 只要垃圾回收器以啟動就會回收弱引用的物件
虛引用：PhantomReference： 如果物件用虛引用包裹，物件只要一使用完就被回收
安卓：3.0之後Google不推薦使用了：art : android runtime
3、改成使用LRU快取：
1.設定最大的使用記憶體：
2.重寫sizeof方法：因為存放物件的時候LRU會計算記憶體的使用大小進行累加，當超出設定的最大使用記憶體的時候會把使用最少的物件移除

LRU 是 Least Recently Used 最近最少使用演算法。

接下來我們看下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.

這段話什麼意思尼？其實就是設個類是個快取作用的類，裡面儲存的資料是強引用，當每次訪問裡面的一個值的時候，那麼就將該數值放到佇列的頭部，另一方面，當新增的資料充滿整個佇列的時候，就將佇列的末尾資料移除，該移除的資料才有可能被系統進行垃圾回收。

其實簡單一句話描述LruCache的功能就是採用佇列方式儲存，採用最近最少使用演算法，維護一個快取。

首先我們看下原始碼部分的建構函式：

 public LruCache(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }
        this.maxSize = maxSize;//設定Lrucache的最大容量
        //初始容量為零，0.75是載入因子，表示容量達到最大容量的75%的時候會把記憶體增加一半。最後這個引數至關重要。
        //表示訪問元素的排序方式，true表示按照訪問順序排序，false表示按照插入的順序排序。（實現Lru演算法的關鍵）
        this.map = new LinkedHashMap<K, V>(0, 0.75f, true);//存放資料的集合
    }

下面再看下 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,並且呼叫entryRemoved方法,entryRemoved是一個空實現，
如果我們使用LruCache的時候需要掌握元素移除的資訊，可以重寫這個方法。最後就會呼叫trimToSize，來調整集合中的內容。

接下來我們再看下 trimToSize方法：

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

該方法的目的就是刪除最老的條目，直到剩餘條目的總數達到或低於要求的大小。具體就是：這個方法是一個無限迴圈，跳出迴圈的條件是，size < maxSize或者 map 為空。主要的功能是判斷當前容量時候已經超出最大的容量，如果超出了maxSize的話，就會迴圈移除map中的第一個元素，直到達到跳出迴圈的條件。由上面的分析知道，map中的第一個元素就是最近最少使用的那個元素。

我們再看下 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++;
        }

        /*
         * 嘗試建立一個值。 這可能需要很長時間，並且create（）返回時map集合可能會有所不同。 
         * 如果在create（）正在工作時將衝突值新增到地圖，則我們將該值保留在地圖中並釋放建立的值。
         */

        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來獲取value,如果能獲取到就就直接返回，獲取不到的話，就呼叫create()方法建立一個，事實上，
如果我們不重寫這個create方法的話是return null的，所以整個流程就是獲取得到就直接返回，獲取不到就返回null。

remove方法：

public final V remove(K key) {
        if (key == null) {
            throw new NullPointerException("key == null");
        }

        V previous;
        synchronized (this) {
            previous = map.remove(key);
            if (previous != null) {
                size -= safeSizeOf(key, previous);
            }
        }

        if (previous != null) {
            entryRemoved(false, key, previous, null);
        }

        return previous;
    }

就是使用remove方法移除一個元素。