管理位图内存

位图内存管理

Android的Android 2.2（ API Level 8）和更低的版本在垃圾收集发生时，应用程序的线程会停止。这将导致应用程序出现卡顿。 

Android 2.3增加了并发垃圾回收，这意味着位图不再被引用时，其内存会被回收再利用。

在Android 2.3.3（ API Level 10）和较低版本中，位图的像素数据被存储在本机内存。而位图本身存储在Dalvik的堆中。本机内存中的像素数据不会以一种可预见的方式被释放，可能会导致应用程序超过其内存限制而崩溃。

到了Android 3.0（ API 11） ，像素数据和关联的位图一起存储在Dalvik堆中。

Android2.3.3和更低版本
推荐使用recycle()回收位图。

下面的代码片段给出了 recycle()的一个例子。它使用了引用计数（变量mDisplayRefCount mCacheRefCount）来跟踪位图是否被显示或在高速缓存中。当条件满足时回收位图

private int mCacheRefCount = 0;
private int mDisplayRefCount = 0;
...
// Notify the drawable that the displayed state has changed.
// Keep a count to determine when the drawable is no longer displayed.
public void setIsDisplayed(boolean isDisplayed) {
    synchronized (this) {
        if (isDisplayed) {
            mDisplayRefCount++;
            mHasBeenDisplayed = true;
        } else {
            mDisplayRefCount--;
        }
    }
    // Check to see if recycle() can be called.
    checkState();
}

// Notify the drawable that the cache state has changed.
// Keep a count to determine when the drawable is no longer being cached.
public void setIsCached(boolean isCached) {
    synchronized (this) {
        if (isCached) {
            mCacheRefCount++;
        } else {
            mCacheRefCount--;
        }
    }
    // Check to see if recycle() can be called.
    checkState();
}

private synchronized void checkState() {
    // If the drawable cache and display ref counts = 0, and this drawable
    // has been displayed, then recycle.
    if (mCacheRefCount <= 0 && mDisplayRefCount <= 0 && mHasBeenDisplayed
            && hasValidBitmap()) {
        getBitmap().recycle();
    }
}

private synchronized boolean hasValidBitmap() {
    Bitmap bitmap = getBitmap();
    return bitmap != null && !bitmap.isRecycled();
}

Android 3.0和更高版本

3.0以上版本提供了BitmapFactory.Options.inBitmap选项，当这个选项被设置时，解码方法在加载位图时会试图使用已经存在的位图，而不用再重新分配和释放内存。

使用这种方法有些需要注意的事项。

• 重复使用的位图必须与源内容（确保使用相同数量的内存）的大小相同，位图格式只能是JPEG或PNG格式（无论是资源或流） 。
• 如果nPreferredConfig 有设置，则重用的位图配置会重载这个设置。
• 尽量使用解码方法返回的位图，因为位图重用不一定能正常执行（例如，大小不匹配） 。

保存位图供以后使用
下面的代码片断演示了如何现有的位图存储供以后使用。在Android 3.0或更高版本，当位图被逐出从LruCache中，该位图的软引用被放置在一个HashSet ，以备稍后可能的重用 ：

HashSet> mReusableBitmaps;
private LruCache mMemoryCache;

// If you're running on Honeycomb or newer, create
// a HashSet of references to reusable bitmaps.
if (Utils.hasHoneycomb()) {
    mReusableBitmaps = new HashSet>();
}

mMemoryCache = new LruCache(mCacheParams.memCacheSize) {

    // Notify the removed entry that is no longer being cached.
    @Override
    protected void entryRemoved(boolean evicted, String key,
            BitmapDrawable oldValue, BitmapDrawable newValue) {
        if (RecyclingBitmapDrawable.class.isInstance(oldValue)) {
            // The removed entry is a recycling drawable, so notify it
            // that it has been removed from the memory cache.
            ((RecyclingBitmapDrawable) oldValue).setIsCached(false);
        } else {
            // The removed entry is a standard BitmapDrawable.
            if (Utils.hasHoneycomb()) {
                // We're running on Honeycomb or later, so add the bitmap
                // to a SoftReference set for possible use with inBitmap later.
                mReusableBitmaps.add
                        (new SoftReference(oldValue.getBitmap()));
            }
        }
    }
....
}

使用存在的位图

public static Bitmap decodeSampledBitmapFromFile(String filename,
        int reqWidth, int reqHeight, ImageCache cache) {

    final BitmapFactory.Options options = new BitmapFactory.Options();
    ...
    BitmapFactory.decodeFile(filename, options);
    ...

    // If we're running on Honeycomb or newer, try to use inBitmap.
    if (Utils.hasHoneycomb()) {
        addInBitmapOptions(options, cache);
    }
    ...
    return BitmapFactory.decodeFile(filename, options);
}

上文的addInBitmapOptions() 方法如果找到匹配位图则为inBitmap赋值。

private static void addInBitmapOptions(BitmapFactory.Options options,
        ImageCache cache) {
    // inBitmap only works with mutable bitmaps, so force the decoder to
    // return mutable bitmaps.
    options.inMutable = true;

    if (cache != null) {
        // Try to find a bitmap to use for inBitmap.
        Bitmap inBitmap = cache.getBitmapFromReusableSet(options);

        if (inBitmap != null) {
            // If a suitable bitmap has been found, set it as the value of
            // inBitmap.
            options.inBitmap = inBitmap;
        }
    }
}

// This method iterates through the reusable bitmaps, looking for one 
// to use for inBitmap:
protected Bitmap getBitmapFromReusableSet(BitmapFactory.Options options) {
        Bitmap bitmap = null;

    if (mReusableBitmaps != null && !mReusableBitmaps.isEmpty()) {
        final Iterator> iterator
                = mReusableBitmaps.iterator();
        Bitmap item;

        while (iterator.hasNext()) {
            item = iterator.next().get();

            if (null != item && item.isMutable()) {
                // Check to see it the item can be used for inBitmap.
                if (canUseForInBitmap(item, options)) {
                    bitmap = item;

                    // Remove from reusable set so it can't be used again.
                    iterator.remove();
                    break;
                }
            } else {
                // Remove from the set if the reference has been cleared.
                iterator.remove();
            }
        }
    }
    return bitmap;
}

最后，本方法确定是否有满足的大小标准要求的用于inBitmap的候选位图：

private static boolean canUseForInBitmap(
        Bitmap candidate, BitmapFactory.Options targetOptions) {
    int width = targetOptions.outWidth / targetOptions.inSampleSize;
    int height = targetOptions.outHeight / targetOptions.inSampleSize;

    // Returns true if "candidate" can be used for inBitmap re-use with
    // "targetOptions".
    return candidate.getWidth() == width && candidate.getHeight() == height;
}