Android Training精要（七）内存管理

在2.3.3及以下版本：

通過定義兩個整形變量來檢測bitmap是否display過或者已經在緩存中

下面的代碼當bitmap滿足兩個條件就被回收掉：

1. 兩個整形變量都變為0

2. bitmap不為null並且還沒有被回收掉

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

Android3.0以上版本内存管理

BitmapFactory.Options.inBitmap：解码器将尝试重用已经存在的位图对象：

4.4之前有以下要求

•被重用的位图对象必须与源内容大小一致，并且是JPEG或PNG格式

•inSampleSize 必須設置成 1

•被重用的位图的configuration将覆盖inPreferredConfig设置，如果有的话

•你应该使用解码方法返回的位图对象。被重用的位图不一定还能用

Set<SoftReference<Bitmap>> mReusableBitmaps; 
private LruCache<String, BitmapDrawable> mMemoryCache; 
 
// If you're running on Honeycomb or newer, create a 
// synchronized HashSet of references to reusable bitmaps. 
if (Utils.hasHoneycomb()) { 
    mReusableBitmaps = 
            Collections.synchronizedSet(new HashSet<SoftReference<Bitmap>>()); 
} 
 
mMemoryCache = new LruCache<String, BitmapDrawable>(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<Bitmap>(oldValue.getBitmap())); 
            } 
        } 
    } 
.... 
}

Decode方法检查是否有现存的位图可用：

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

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()) { 
        synchronized (mReusableBitmaps) { 
            final Iterator<SoftReference<Bitmap>> 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; 
}

static boolean canUseForInBitmap( 
        Bitmap candidate, BitmapFactory.Options targetOptions) { 
 
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) { 
        // From Android 4.4 (KitKat) onward we can re-use if the byte size of 
        // the new bitmap is smaller than the reusable bitmap candidate 
        // allocation byte count. 
        int width = targetOptions.outWidth / targetOptions.inSampleSize; 
        int height = targetOptions.outHeight / targetOptions.inSampleSize; 
        int byteCount = width * height * getBytesPerPixel(candidate.getConfig()); 
        return byteCount <= candidate.getAllocationByteCount(); 
    } 
 
    // On earlier versions, the dimensions must match exactly and the inSampleSize must be 1 
    return candidate.getWidth() == targetOptions.outWidth 
            && candidate.getHeight() == targetOptions.outHeight 
            && targetOptions.inSampleSize == 1; 
} 
 
/** 
 * A helper function to return the byte usage per pixel of a bitmap based on its configuration. 
 */ 
static int getBytesPerPixel(Config config) { 
    if (config == Config.ARGB_8888) { 
        return 4; 
    } else if (config == Config.RGB_565) { 
        return 2; 
    } else if (config == Config.ARGB_4444) { 
        return 2; 
    } else if (config == Config.ALPHA_8) { 
        return 1; 
    } 
    return 1; 
}