图片缓存（源于SDK文档）

接着之前的《一种异步加载资源的方法（源于SDK文档）》，SDK文档在《Caching Bitmaps》中介绍了内存缓存与磁盘缓存的使用。

大家都知道，现在的手机屏幕分辨率是越来越大了，虽然之前我们介绍了异步加载图片的方法。但要知道，一个应用可用的内存是有限的。我们不可能将所有的内存都用来存储图片，也不可能为了内存而每次取图片时都上网下载（流量费是很贵滴，而且下载也很耗电啊）。

因此，对于已下载的图片，我们需要在本地维持一个缓存。

内存缓存

LurCache是一个内存缓存类（Android3.1引入，通过v4的支援包，可以在API Level 4以上使用）。它使用一个强连接的LinkedHashMap，将使用频率最高的图片缓存在内存中。

PS:在这之前，最流行的缓存方式是使用SoftReference与WeakReference。但从Android2.3开始，垃圾回收对于软引用与弱引用来说，变得越来越积极了。这也就造成了软引用与弱引用的效率变得很低（没几下就被回收了，然后又得再创建，和没缓存没太大区别）。同时，在Android3.0之前，Bitmap的数据是储存在所谓的native内存区中（可以想象成是用C语言申请的内存，很难被垃圾回收自动释放）。这也造成了应用非常容易发生内存溢出。

当然，要想使用LurCache，我们需要给定一个缓存大小。而要想确定缓存占多少内存，需要考虑以下条件：

• 应用的其他地方对内存的占用有多紧张？
• 有多少图片会同时在屏幕上显示？在它们显示时，要确保多少的其余图片可以马上显示而无明显延迟？
• 屏幕大小与密度如何？xhdpi的机子明显要比hdpi的机子需要更多的缓存。
• 每张图片大概有多大？
• 图片访问的频率是多少？有没有部分图片的访问频率远高于其他图片？如果是的话，你可能需要将这些图片进行缓存，甚至需要多个LurCache对象来缓存不同等级的图片。
• 你可以平衡质量与数量吗？有的时候，存储大量低分辨率的图片更有用。你可以在后台任务中加载高分辨率的。

没有绝对合适的大小或计算方法，你必须根据自身应用的特点来确定相应的解决方案。缓存太小，反而会由于频繁的重新创建而降低效率。缓存太大，自然也同样会造成内存溢出了。

以下是一个使用LurCache的例子，使用八分之一的可用内存作为缓存。在一个普通的hdpi的机子上，大概是4MB以上。

在一个800x480的屏幕上的全屏GridView显示的图片，大概需要1.5MB (800*480*4 bytes)的内存。也就是说，这个例子里的缓存，可以保存至少2.5屏的图片。

    private LruCache<String, Bitmap> mMemoryCache;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ...
        // 获取可用内存的最大值，超过这个数，就会产生OutOfMemory.
        // 将其以KB为单位存储.
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        // 使用八分之一的可用内存作为缓存.
        final int cacheSize = maxMemory / 8;
        mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                // 缓存大小以KB为单位进行计算.
                return bitmap.getByteCount() / 1024;
            }
        };
        ...
    }

    public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
        if (getBitmapFromMemCache(key) == null) {
            mMemoryCache.put(key, bitmap);
        }
    }

    public Bitmap getBitmapFromMemCache(String key) {
        return mMemoryCache.get(key);
    }

接着《一种异步加载资源的方法（源于SDK文档）》的例子，在加载图片时，先去缓存里查一下。如果缓存里有，直接设上去就行了。

    public void loadBitmap(int resId, ImageView imageView) {
        final String imageKey = String.valueOf(resId);
        final Bitmap bitmap = getBitmapFromMemCache(imageKey);
        if (bitmap != null) {
            mImageView.setImageBitmap(bitmap);
        } else {
            mImageView.setImageResource(R.drawable.image_placeholder);
            BitmapWorkerTask task = new BitmapWorkerTask(mImageView);
            task.execute(resId);
        }
    }

 

当然，BitmapWorkerTask也需要更新一下，当图片获取到后，将其加入缓存。

class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {   
    ...   
    // Decode image in background.
    @Override
    protected Bitmap doInBackground(Integer... params) {
        final Bitmap bitmap = decodeSampledBitmapFromResource(
                getResources(), params[0], 100, 100);
        addBitmapToMemoryCache(String.valueOf(params[0]), bitmap);
        return bitmap;
    }
    ...
}

 磁盘缓存

虽然内存缓存很有用，但光靠它还是不够的。像一些专门看图片的应用，里面的照片多了去了。很容易缓存就满了。或者当应用在后台被杀死时，内存缓存也会立刻清空。你还是得重新建立。

在这种情况下，就需要磁盘缓存来将图片保存到本地。这样，当内存缓存被清空时，可以通过磁盘缓存加快图片的加载。

以下的例子就是使用源码中提供的DiskLurCache来完成磁盘缓存的功能。

它并不是替代内存缓存，而是在内存缓存之外再额外备份了一次。

    private DiskLruCache mDiskLruCache;
    private final Object mDiskCacheLock = new Object();
    private boolean mDiskCacheStarting = true;
    private static final int DISK_CACHE_SIZE = 1024 * 1024 * 10; // 10MB
    private static final String DISK_CACHE_SUBDIR = "thumbnails";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        ...
        // Initialize memory cache

        ...
        // Initialize disk cache on background thread
        File cacheDir = getDiskCacheDir(this, DISK_CACHE_SUBDIR);
        new InitDiskCacheTask().execute(cacheDir);
        ...
    }

    class InitDiskCacheTask extends AsyncTask<File, Void, Void> {
        @Override
        protected Void doInBackground(File... params) {
            synchronized (mDiskCacheLock) {
                File cacheDir = params[0];
                mDiskLruCache = DiskLruCache.open(cacheDir, DISK_CACHE_SIZE);
                mDiskCacheStarting = false; // Finished initialization
                mDiskCacheLock.notifyAll(); // Wake any waiting threads
            }
            return null;
        }
    }

    class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {
        ...
        // Decode image in background.
        @Override
        protected Bitmap doInBackground(Integer... params) {
            final String imageKey = String.valueOf(params[0]);
            // Check disk cache in background thread
            Bitmap bitmap = getBitmapFromDiskCache(imageKey);
            if (bitmap == null) {
                // Not found in disk cache
                // Process as normal
                final Bitmap bitmap = decodeSampledBitmapFromResource(
                        getResources(), params[0], 100, 100);
            }
            // Add final bitmap to caches
            addBitmapToCache(imageKey, bitmap);
            return bitmap;
        }
        ...
    }

    public void addBitmapToCache(String key, Bitmap bitmap) {
        // Add to memory cache as before
        if (getBitmapFromMemCache(key) == null) {
            mMemoryCache.put(key, bitmap);
        }
        // Also add to disk cache
        synchronized (mDiskCacheLock) {
            if (mDiskLruCache != null && mDiskLruCache.get(key) == null) {
                mDiskLruCache.put(key, bitmap);
            }
        }
    }

    public Bitmap getBitmapFromDiskCache(String key) {
        synchronized (mDiskCacheLock) {
            // Wait while disk cache is started from background thread
            while (mDiskCacheStarting) {
                try {
                    mDiskCacheLock.wait();
                } catch (InterruptedException e) {
                }
            }
            if (mDiskLruCache != null) {
                return mDiskLruCache.get(key);
            }
        }
        return null;
    }

    // Creates a unique subdirectory of the designated app cache directory.
    // Tries to use external
    // but if not mounted, falls back on internal storage.
    public static File getDiskCacheDir(Context context, String uniqueName) {
        // Check if media is mounted or storage is built-in, if so, try and use
        // external cache dir
        // otherwise use internal cache dir

        final String cachePath = Environment.MEDIA_MOUNTED.equals(Environment
                .getExternalStorageState()) || !isExternalStorageRemovable() ? getExternalCacheDir(
                context).getPath() : context.getCacheDir().getPath();
        return new File(cachePath + File.separator + uniqueName);
    }

 

PS:即使是初始化磁盘缓存，也需要相应的磁盘操作。因此，使用了一个异步任务InitDiskCacheTask来进行。另外，为了防止在磁盘缓存建立成功前就去访问，在getBitmapFromDiskCache方法中，进行了wait操作。当磁盘缓存初始化后，如果提前访问了，相应的线程将被notifyAll唤醒。

处理Configuration Change

在程序运行时，我们经常会遇到Configuration Change，像横竖屏切换、语言改变等等。

而这些情况，往往会使得当前运行的Activity被销毁并重新创建。

为了防止在销毁与创建过程中重新建立缓存（耗时太久且影响效率，要是能直接保存就好了），我们可以通过Fragment。只要setRetainInstance(true)就行了。

如下图所示，在Activity的onCreate里，先判断相应的Fragment在不在FragmentManager里，要是在的话，直接获取相应的缓存对象。并且在Fragment的onCreate中setRetainInstance(true)。

private LruCache<String, Bitmap> mMemoryCache;

@Override
protected void onCreate(Bundle savedInstanceState) {
    ...
    RetainFragment mRetainFragment =
            RetainFragment.findOrCreateRetainFragment(getFragmentManager());
    mMemoryCache = RetainFragment.mRetainedCache;
    if (mMemoryCache == null) {
        mMemoryCache = new LruCache<String, Bitmap>(cacheSize);
        ... // Initialize cache here as usual

        mRetainFragment.mRetainedCache = mMemoryCache;
    }
    ...
}

class RetainFragment extends Fragment {
    private static final String TAG = "RetainFragment";
    public LruCache<String, Bitmap> mRetainedCache;

    public RetainFragment() {
    }

    public static RetainFragment findOrCreateRetainFragment(FragmentManager fm) {
        RetainFragment fragment = (RetainFragment) fm.findFragmentByTag(TAG);
        if (fragment == null) {
            fragment = new RetainFragment();
        }
        return fragment;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRetainInstance(true);
    }
}