Android 之 三级缓存（内存!!!、本地、网络）及内存LruCache扩展 及源码分析--- 学习和代码讲解

一. 三级缓存简介

如上图所示，目前App中UI界面经常会涉及到图片，特别是像“今日关注”新闻这类app中，图片运用的几率十分频繁。当手机上需要显示大量图片类似listView、gridView控件并且用户会上下滑动，即将浏览过的图片又加载一遍，若是不停的进行网络请求，很快就会OOM，这时三级缓存显得尤为重要，适时地利用资源，进行图片缓存，下面就用一个新闻组图demo进行图片缓存演示。

1.三级缓存的顺序
（1）内存缓存： 比如说需要加载图片时，系统第一步不会直接网络请求，而是首先找第一级缓存—内存缓存
（2）本地缓存： 如果内存缓存中没有，就会从第二级缓存—本地缓冲（即sd卡）
（3）网络缓存： 如果本地缓存中没有，就会从网络缓存中下载图片。

2. 三级缓存级别总结
（1）内存缓存： 速度快, 优先读取
（2）本地缓存： 速度其次, 内存没有,读本地
（3）网络缓存： 速度最慢, 本地也没有,才访问网络

---

---

---

二. 代码实现

关于这个三级缓存的实现，其实 Xutils开源项目中BitmapUtils已经替我们封装好了，下面新建一个MyBitmapUtils，自己实现三级缓存。

1.网络缓存（NetCacheUtils ）

  /**
     * 三个泛型意义:
     * 第一个泛型:doInBackground里的参数类型
     * 第二个泛型: onProgressUpdate里的参数类型
     * 第三个泛型:
     * onPostExecute里的参数类型及doInBackground的返回类型
     */
    private class BitmapTask extends AsyncTask<Object, Integer,Bitmap>{
        //1.预加载，运行在主线程
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }
        //2.正在加载，运行在子线程（核心方法），可以直接异步请求
        @Override
        protected Bitmap doInBackground(Object[] objects) {
            return null;
        }
        //3.更新进度的方法，运行在主线程
        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
        }
        //4.加载结束，运行在主线程（核心方法），可以直接更新UI
        @Override
        protected void onPostExecute(Bitmap bitmap) {
            super.onPostExecute(bitmap);
        }
    }

这里的逻辑就是 doInBackground方法 异步网络请求图片，onPostExecute方法将图片加载呈现出来。而 onPreExecute 的作用是预加载，使用不常。至于onProgressUpdate 可显示出请求图片过程中的进度，这两个并非核心方法。

（1）doInBackground ： 核心方法，请求网络。大家都知道请求网络是一个耗时操作，需要在子线程中进行，这里也确实如此，不过不需要我们再new 一个Thread ，查看源码可知异步AsyncTask已经帮我们做到了。在这一步需要做的就是，获得方法参数中的url，进行网络请求，下载图片获得Bitmap.

（2）onPostExecute： 核心方法，图片加载完成后，显示在手机屏幕上。大家也了解子线程中无法做UI更新，需要使用消息机制，给handler发送消息，在主线程中更新UI。这里异步也都替我们做好了，查看源码可知UI更新是在异步中的hanler中进行。在这一步需要做的就是，将请求获得的Bitmap呈现到屏幕上。（更规范的是，还要将获得的Bitmap存储到内存和本地中，方便下次使用时可拿取缓存，不需重复请求网络！！！）

/**
 * 网络缓存工具类
 * 
 * 
 */
public class NetCacheUtils {

    LocalCacheUtils mLocalCacheUtils;
    MemoryCacheUtils mMemoryCacheUtils;

    public NetCacheUtils(LocalCacheUtils localCacheUtils,
            MemoryCacheUtils memoryCacheUtils) {
        mLocalCacheUtils = localCacheUtils;
        mMemoryCacheUtils = memoryCacheUtils;
    }

    public void getBitmapFromNet(ImageView ivPic, String url) {
        BitmapTask task = new BitmapTask();
        task.execute(new Object[] { ivPic, url });
    }

    class BitmapTask extends AsyncTask<Object, Void, Bitmap> {

        private ImageView imageView;
        private String url;

        /**
         * 返回的对象会自动回传到onPostExecute里面
         */
        @Override
        protected Bitmap doInBackground(Object... params) {
            imageView = (ImageView) params[0];
            url = (String) params[1];
            imageView.setTag(url);
            Bitmap bitmap = downloadBitmap(url);
            return bitmap;
        }

        @Override
        protected void onPostExecute(Bitmap result) {
            // 这里的result就是doInBackground返回回来的对象
            if (result != null) {
                String ivUrl = (String) imageView.getTag();
                if (url.equals(ivUrl)) {// 确保imageview设置的是正确的图片（因为有时候listview有重用机制，多个item会公用一个imageview对象，从而导致图片错乱）
                    imageView.setImageBitmap(result);
                    System.out.println("从网络缓存读取图片");

                    // 向本地保存图片文件
                    mLocalCacheUtils.putBitmapToLocal(url, result);
                    // 向内存保存图片对象
                    mMemoryCacheUtils.putBitmapToMemory(url, result);
                }
            }
        }
    }

    /**
     * 下载图片
     * 
     * @param url
     * @return
     */
    private Bitmap downloadBitmap(String url) {
        HttpURLConnection conn = null;
        try {
            conn = (HttpURLConnection) new URL(url).openConnection();
            conn.setConnectTimeout(5000);
            conn.setReadTimeout(5000);
            conn.setRequestMethod("GET");
            conn.connect();

            int responseCode = conn.getResponseCode();
            if (responseCode == 200) {
                InputStream inputStream = conn.getInputStream();

                //图片压缩
                BitmapFactory.Options options = new BitmapFactory.Options();
                options.inSampleSize = 2;//表示压缩比例，2表示宽高都压缩为原来的二分之一， 面积为四分之一
                options.inPreferredConfig = Config.RGB_565;//设置bitmap的格式，565可以降低内存占用

                Bitmap bitmap = BitmapFactory.decodeStream(inputStream, null, options);
                return bitmap;
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            conn.disconnect();
        }

        return null;
    }
}

---

---

2. 本地缓存（LocalCacheUtils ）

/**
 * 本地缓存工具类
 * 
 * 
 */
public class LocalCacheUtils {

    private static final String LOCAL_PATH = Environment
            .getExternalStorageDirectory().getAbsolutePath() + "/zhbj_cache";

    /**
     * 从本地读取图片
     * 
     * @param url
     * @return
     */
    public Bitmap getBitmapFromLocal(String url) {
        try {
            String fileName = MD5Encoder.encode(url);
            File file = new File(LOCAL_PATH, fileName);

            if (file.exists()) {
                // 图片压缩
                BitmapFactory.Options options = new BitmapFactory.Options();
                options.inSampleSize = 2;// 表示压缩比例，2表示宽高都压缩为原来的二分之一， 面积为四分之一
                options.inPreferredConfig = Config.RGB_565;// 设置bitmap的格式，565可以降低内存占用

                Bitmap bitmap = BitmapFactory.decodeStream(new FileInputStream(
                        file), null, options);
                return bitmap;
            } else {
                return null;
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 向本地存图片
     * 
     * @param url
     * @param bitmap
     */
    public void putBitmapToLocal(String url, Bitmap bitmap) {
        try {
            String fileName = MD5Encoder.encode(url);
            File file = new File(LOCAL_PATH, fileName);
            File parent = file.getParentFile();

            // 创建父文件夹
            if (!parent.exists()) {
                parent.mkdirs();
            }

            bitmap.compress(CompressFormat.JPEG, 100,
                    new FileOutputStream(file));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

如上所示，这里对于本地（sd卡）缓存的操作就两个方法，比较单一，一个存储缓存数据方法—putBitmapToLocal，一个拿取缓存数据方法—getBitmapToLocal

（1）putBitmapToLocal： 这里我们将每个存储图片的文件名设为 图片对应的url地址（MD5加密后的），判断父文件是否存在，不存在则新建，存在则直接存储进去。

（2）getBitmapToLocal： 先从方法参数中获取到图片对应的url，进行查找，若存在则将图片的Bitmap返回回去（最好返回前先压缩），不存在则返回null。

---

---

---

---

3. 内存缓存（LocalCacheUtils ）重点！！！

3.1 HashMap版

/**
 * 内存缓存工具类
 */
public class MemoryCacheUtils {

     HashMap<String, Bitmap> mMemoryCache = new HashMap<String, Bitmap> ；
    /**
     * 从内存读取图片
     * 
     * @param url
     * @return
     */
    public Bitmap getBitmapFromMemory(String url) {
    Bitmap bitmap = mMemoryCache.get(url);
        return bitmap;
    }

    /**
     * 向内存存图片
     * 
     * @param url
     * @param bitmap
     */
    public void putBitmapToMemory(String url, Bitmap bitmap) {
        mMemoryCache.put(url, bitmap);
    }
}

如上所示，这里对于内存缓存的操作也是两个方法，一个是设置内存缓存方法—putBitmapToLocal，一个是取内存缓存方法—getBitmapToLocal。用对象来存储图片，集合来存储对象，集合都在内存里面，所以决定用集合。

关于Android，集合就涉及到两个，ArrayList用的多，但是取数据时必须要传递数组位置；但是Hashmap用的是键值对结构，只要有了key，就可以找到对应的value。（而我们这里的key就是每张图片对应的url，value就是每个图片　Bitmap对象）

---

---

3.2 软引用版

你说以上就是内存缓存的重点？绝对不可能，Bitmap对象虽存在于集合中，但我们每次都 new 一个新的Bitmap，如果有大量的图片，集合内存根本不够，很快就会OOM，也就是内存溢出。也许你的手机内存很大，但是不管安卓设备总内存有多大，它只给每个APP分配一定内存大小（16M），所以内存是非常有限的，而且在这里 垃圾回收机制是不起作用的！

3.2.1 栈、堆、垃圾回收器
如上图所示，内存缓存这里涉及到栈和堆。java里的栈一般存的是成员变量、方法声明、引用之类的。堆里存储的是一个又一个的对象。（例如，new了一个 p，p存在栈里，但是 person对象存储在 堆中，p引用，指向一个person对象）。垃圾回收器会定时地从堆里回收圾释放内存。（例如上图，只要栈与堆中的连接断掉，堆中的对象就是垃圾，回收站可进行回收。所以说，垃圾回收器有个特点：只回收没有引用的对象！）

再回到内存溢出上，我们
HashMap<String,Bitmap> mMemoryCache = new HashMap<String, Bitmap> ；
集合中有许多个对象，都被集合引用！这个引用一直在！垃圾回收器并不会回收，所以会导致内存溢出。以上只是一方面，而且即使它会回收这些引用的集合，可它是隔一段时间才会回收，无法及时清理内存！

---

现在我们需要解决的是：能否在引用的情况下，垃圾回收器可以照样回收？

3.2.2 内存缓存中的 引用级别

（1） 强引用 默认引用, 即使内存溢出,也不会回收

（2） 软引用 SoftReference, 内存不够时, 会考虑回收

（3） 弱引用 WeakReference 内存不够时, 更会考虑回收

（4）虚引用 PhantomReference 内存不够时, 最优先考虑回收!

像Person p = new Person();就属于强引用。回收器断然不会回收！而虚引用则太容易被回收，所以最常用的是软引用 和 弱引用，在需求不强烈或内存实在是不够的情况下，垃圾回收器才会回收引用的对象。我们主要回收的是Bitmap对象，对集合进行包装，使用软引用。

//用法举例
Bitmap bitmap = new Bitmap();
SoftReference<Bitmap> sBitmap = new SoftReference<Bitmap>(bitmap);
Bitmap bitmap2 = sBitmap.get();

( 软引用版）：

/**
 * 内存缓存工具类
 */
public class MemoryCacheUtils {

     HashMap<String, SoftReference<Bitmap>> mMemoryCache = new HashMap<String, SoftReference<Bitmap>> ；
    /**
     * 从内存读取图片
     * 
     * @param url
     * @return
     */
    public Bitmap getBitmapFromMemory(String url) {
    SoftReference<Bitmap> softBitmap = mMemoryCache.get(url);

    if(softReference != null){
        Bitmap bitmap = softReference.get();
        return bitmap;
     }
    return null;    
}

    /**
     * 向内存存图片
     * 
     * @param url
     * @param bitmap
     */
    public void putBitmapToMemory(String url, Bitmap bitmap) {
        SoftReference<Bitmap> softBitmap = new SoftReference<Bitmap>(bitmap);
        mMemoryCache.put(url, bitmap);
    }
}

---

---

3.3 LruCache 版（重点！！！）

（一位大神关于这一点的讲解，很好，下面有引用部分
http://blog.csdn.net/fancylovejava/article/details/25705169）

可是自从 Android 2.3 (API Level 9)开始，垃圾回收器会更倾向于回收持有软引用或弱引用的对象，这让软引用和弱引用变得不再可靠。这么说来即使内存很充分的情况下，也有优先回收弱引用和软引用。
官方文档的截图：

https://developer.android.com/training/displaying-bitmaps/cache-bitmap.html官方链接

翻译：
在过去，我们经常会使用一种非常流行的内存缓存技术的实现，即软引用或弱引用 (SoftReference or WeakReference)。
但是现在已经不再推荐使用这种方式了，因为从 Android 2.3 (API Level 9)开始，垃圾回收器会更倾向于回收持有软引用或弱引用的对象，
这让软引用和弱引用变得不再可靠。另外，Android 3.0 (API Level 11)中，图片的数据会存储在本地的内存当中，因而无法用一种可预见的方式将其释放，
这就有潜在的风险造成应用程序的内存溢出并崩溃。所以看到还有很多相关文章还在推荐用软引用或弱引用 (SoftReference or WeakReference)，就有点out了。

---

所以为了解决这个问题，google为我们推荐了LruCache类，这个类在 V4包 下，非常适合用来缓存图片。

3.3.1 LruCache
Lru定义 :least recentlly used 最近最少使用的算法。（比如说，先后使用A、B、C、A、C、D对象，这时会回收的则是B对象。）
LruCache : 可以将最近最少使用的对象回收掉, 从而保证内存不会超出范围！

3.3.2 分配空间


获得分配给App最大的内存大小 —— 16M（16777216/1024）

long maxMemory = Runtime.getRuntime().maxMemory();
mMemoryCache = new LruCache<String, Bitmap>((int) (maxMemory / 8)) 

但是在分配内存的过程中，切不可一次分配全部内存出去，毕竟这只是App的一部分模块，其余部分还需要空间。（分配1/8 —— 2M）

3.3.2 重写LruCache 的 sizeOf方法
这个方法要返回每个对象的大小。Lru要控制内存的总大小，所以它需要知道每个Bitmap有多大。所以需要重写这个方法，让开发者自己计算，返回大小。

            protected int sizeOf(String key, Bitmap value) {
                // int byteCount = value.getByteCount();
                int byteCount = value.getRowBytes() * value.getHeight();// 计算图片大小:每行字节数*高度
                return byteCount;
            }

---

---

( LruCache版）：

private LruCache<String, Bitmap> mMemoryCache;

    public MemoryCacheUtils() {

        long maxMemory = Runtime.getRuntime().maxMemory();// 获取分配给app的内存大小
        System.out.println("maxMemory:" + maxMemory);

        mMemoryCache = new LruCache<String, Bitmap>((int) (maxMemory / 8)) {

            // 返回每个对象的大小
            @Override
            protected int sizeOf(String key, Bitmap value) {
                // int byteCount = value.getByteCount();//有版本兼容问题
                int byteCount = value.getRowBytes() * value.getHeight();// 计算图片大小:每行字节数*高度
                return byteCount;
            }
        };
    }

    /**
     * 写缓存
     */
    public void setMemoryCache(String url, Bitmap bitmap) {
        mMemoryCache.put(url, bitmap);
    }

    /**
     * 读缓存
     */
    public Bitmap getMemoryCache(String url) {
        return mMemoryCache.get(url);
    }

---

---

---

---

4. 工具类，将以上三级缓存封装起来

/**
 * 自定义三级缓存图片加载工具
 */
public class MyBitmapUtils {

    private NetCacheUtils mNetCacheUtils;
    private LocalCacheUtils mLocalCacheUtils;
    private MemoryCacheUtils mMemoryCacheUtils;

    public MyBitmapUtils() {
        mMemoryCacheUtils = new MemoryCacheUtils();
        mLocalCacheUtils = new LocalCacheUtils();
        mNetCacheUtils = new NetCacheUtils(mLocalCacheUtils, mMemoryCacheUtils);
    }

    public void display(ImageView imageView, String url) {
        // 设置默认图片
        imageView.setImageResource(R.drawable.pic_item_list_default);

        // 优先从内存中加载图片, 速度最快, 不浪费流量
        Bitmap bitmap = mMemoryCacheUtils.getMemoryCache(url);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
            System.out.println("从内存加载图片啦");
            return;
        }

        // 其次从本地(sdcard)加载图片, 速度快, 不浪费流量
        bitmap = mLocalCacheUtils.getLocalCache(url);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
            System.out.println("从本地加载图片啦");

            // 写内存缓存
            mMemoryCacheUtils.setMemoryCache(url, bitmap);
            return;
        }

        // 最后从网络下载图片, 速度慢, 浪费流量
        mNetCacheUtils.getBitmapFromNet(imageView, url);
    }

}

以上，将工具类封装号之后，我们可以不使用 Xutils里的方法，使用我们自定义的MyBitmapUtils，以下代码为调用过程。

class PhotoAdapter extends BaseAdapter {

        //private BitmapUtils mBitmapUtils;
        private MyBitmapUtils mBitmapUtils;

        public PhotoAdapter() {
            mBitmapUtils = new MyBitmapUtils();
            //mBitmapUtils = new BitmapUtils(mActivity);
//          mBitmapUtils
//                  .configDefaultLoadingImage(R.drawable.pic_item_list_default);
        }

---

---

---

---

---

三. 结果呈现

呈现出来的顺序就是：

这是我测试之后的，如果是第一次打开这个模块，最先使用的只能是网络缓存，一旦第一次进行网络缓存后，本地缓存和内存缓存就会有相应的数据。下一次再打开此模块时，首先加载的是本地缓存，得到Bitmap**对象后，之后进行的都是 内存缓存**了。

---

---

四. LruCache扩展及源码分析（重点）

Lru 就像我们家用的洗漱池里小开口，水龙头流出来的水就像是内存，所以我们的洗漱池会堵吗？不会！如果你把口子给堵起来防水，很快水就会满出来，就像是 内存溢出。这里，我们来看下 V4 包下的 LruCache 源码 。

public class LruCache<K, V> {
    private final LinkedHashMap<K, V> map;

点进去一看，Lrucache是一个泛型，它维护了一个 LinkedHashMap，将来在存图片的时候，底层也是存在一个HashMap里。

---

1. LruCache 的 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;
    }

我们去找它的一个put 方法。
previous = map.put(key, value);标记感叹号地方 的 map 就是 一开始的 LinkedHashMap，底层就是对HashMap的封装。
size += safeSizeOf(key, value);
全局维护了一个变量size，时时在统计集合目前对象大小。它走的就是sizeOf方法。但是源码中方法返回的是1，

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

所以我们需要去重写它的sizeOf方法。所以LruCache 在put 的时候都会把总大小计算出来，然后调用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 || 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);
        }
    }

一上来就是一个While循环，先不看抛出异常，直接看if判断if (size <= maxSize || map.isEmpty()) { break; }，如果内存正常，则break出去，否则

   Map.Entry<K, V> toEvict = map.entrySet().iterator().next();
                key = toEvict.getKey();
                value = toEvict.getValue();
                map.remove(key);
                size -= safeSizeOf(key, value);
                evictionCount++;

通过map 拿到迭代器的第一个对象，再直接拿到key，再remove出去，所以总内存大小就减少了。这时继续While循环，因为减少一个不一定符合大小，所以一直减少直到内存大小少于规定值为止！

所以LruCache所谓的算法：可以将最近最少使用的对象回收掉, 从而保证内存不会超出范围。
其中的核心原理就在这里，不停的删掉开头的key，这就是最近最少用的对象。

---

2. LruCache 的 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++;
        }

这里的get方法则更简单，参数将 key 传过来，直接从map中get出对象，再return出来就行了。

---

3. LruCache 的 核心
最核心的地方其实就是维护一个 HashMap，再设置了一个全局变量 size来计算变量的总大小。一旦超出大小，就开始删除对象，从而保证内存量在规定范围内！

---

---

---

---

呼~这篇文章总算写完了，拖了好多天，希望对你们有帮助 ：）