Управление памятью растровых изображений

В дополнение к этапам, описанным в разделе Кэширование растровых изображений, есть определенные вещи, которые вы можете сделать, чтобы облегчить сбор мусора и повторное использования растровых изображений. Рекомендуемая стратегия зависит от версии Android, на которую вы ориентируетесь. Образец приложения BitmapFun , поставляемый с этим уроком покажет вам, как создать своё приложение для эффективной работы на различных версиях Android.

Чтобы подготовить почву для этого урока, ниже описано как изменилось управление растровой памятью в Android:

  • На Android Android 2.2 (API уровнь 8) и ниже, когда происходит сбор мусора, потоки вашего приложения останавливают. Это вызывает задержку и может снизить производительность. В Android 2.3 добавили параллельную сборку мусора, а это значит, что память будет утилизирована вскоре после как на растровое изображение больше не ссылаются.
  • На Android 2.3.3 (API уровень 10) и ниже, пиксельные данные растрового изображения хранились непосредственно в оперативной памяти. Т.е. отдельно от самого растрового изображения, который хранится в Dalvik куче. Данные пикселей в оперативной памяти не освобождались предсказуемым образом, что могло привести приложение к быстрому превышению своего предела памяти и к сбою. Начиная с Android 3.0 (API уровень 11), пиксельные данные хранятся в Dalvik куче вместе с соответствующим растровым изображением.

В следующих разделах описывается, как оптимизировать управление памятью растровых изображений для различных версий Android.

Управление памятью на Android 2.3.3 и ниже

На Android 2.3.3 (API уровень 10) и ниже, использование recycle() рекомендовано. Если вы отображаете большое количество растровых изображений в вашем приложении, вы, вероятно, столкнулись с OutOfMemoryError ошибками. recycle() метод позволяет приложению вернуть память как можно скорее.

Внимание: Вы должны использовать recycle() только тогда, когда вы уверены, что растровое изображение больше не используются. Если вы вызовите recycle() а затем попытаетесь отрисовать растровое изображение, вы получите сообщение об ошибке: "Canvas: trying to use a recycled bitmap".

Следующий фрагмент кода содержит пример вызова recycle(). Он использует подсчет ссылок (в переменных mDisplayRefCount и mCacheRefCount) , чтобы отслеживать отображается ли в данный момент растровое изображение или хранится ли оно в кэше. Код перерабатывает растровые изображения при выполнении следующих условий:

  • Счетчик ссылок для обоих mDisplayRefCount и mCacheRefCount равен 0.
  • Растровое изображение не 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();
}

Управление памятью на Android 3.0 и выше

Android 3.0 (API уровень 11) вводит BitmapFactory.Options.inBitmap поле. Если эта опция установлена, методы декодирования, которые принимают Options объект будут пытаться повторно использовать существующее растровое изображение при загрузке содержимого. Это означает, что память растрового изображения используется повторно, что приводит к повышению производительности, и устраняет как распределение памяти и перераспределение. Тем не менее, есть определенные ограничения того, как inBitmap можно использовать. В частности, до Android 4.4 (API уровень 19), поддерживались только равные по размеру растровые изображения. Для получения дополнительной информации, см. inBitmap документация.

Сохранить растровое изображение для дальнейшего использования

Следующий фрагмент демонстрирует, как существующее растровое изображение хранится для возможного дальнейшего использования в приложении нашего примера. Когда приложение работает на Android 3.0 или выше и растровое изображение выселено из LruCache, мягкая ссылка на растровое изображение помещается в HashSet, для возможного повторного использования позже с inBitmap:

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

Использование существующего растрового изображения

В работающем приложении, методы декодера проверяют можно ли использовать существующее растровое изображение. Например:

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. Следует отметить, что этот метод устанавливает значение для 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()) {
        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;
}

В заключение, этот метод определяет, удовлетворяет ли кандидат критериям размера, который будет использоваться для inBitmap:

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