Введение в этот раздел:

В предыдущем разделе мы уже изучили базовое использование Bitmap. В этом разделе мы обсудим проблемы OOM, вызванные Bitmap. Вы могли или не могли сталкиваться с проблемами OOM, вызванными Bitmap, в реальной разработке. В этом разделе мы изучим эту тему: поймём, что такое OOM, почему это приводит к OOM, и способы улучшения проблем OOM, вызванных Bitmap.


1. Что такое OOM? Почему это приводит к OOM?

Ответ:Out Of Memory(Out of Memory). Мы все знаем, что система Android выделяет каждому приложению независимое рабочее пространство или отдельную виртуальную машину Dalvik, чтобы каждое приложение могло работать независимо, не влияя на другие! В Android для каждой виртуальной машины Dalvik есть ограничение максимального объёма памяти. Если текущий занятый объём памяти плюс запрашиваемые нами ресурсы памяти превышают этот лимит, система выдаст ошибку OOM! Кроме того, не путайте это с ОЗУ. Даже если осталось более 1G ОЗУ, OOM всё равно может возникнуть! Не приравнивайте ОЗУ (физическую память) к OOM! Кроме того, при нехватке ОЗУ приложение уничтожается, а не просто возникает OOM! Максимальный стандарт памяти в Dalvik различается для разных устройств. Можно вызвать:

ActivityManager activityManager = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);
Log.e("HEHE","最大内存:" + activityManager.getMemoryClass());

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

adb shell getprop | grep dalvik.vm.heapgrowthlimit

Вы также можете открыть файл /system/build.prop из системного исходного кода и посмотреть эту часть информации в файле, чтобы выяснить:

dalvik.vm.heapstartsize=8m
dalvik.vm.heapgrowthlimit=192m
dalvik.vm.heapsize=512m
dalvik.vm.heaptargetutilization=0.75
dalvik.vm.heapminfree=2m
dalvik.vm.heapmaxfree=8m

Нас интересуют три места: heapstartsize — это начальный размер памяти кучи, heapgrowthlimit — максимальный размер памяти кучи для стандартного приложения, а heapsize — максимальный размер памяти кучи для приложения, настроенного использовать android:largeHeap!

Здесь я протестировал стандартные максимальные нормативы выделения памяти нескольких устройств под рукой:

Вы также можете попробовать на своём устройстве.

Ладно, хватит отступлений. Что касается возникновения проблем OOM, на этом мы остановимся. Если пойти дальше, мы дойдём до управления памятью, а это большая тема, и сейчас слишком сложно её осилить... Ниже давайте рассмотрим несколько советов по избежанию OOM, связанного с Bitmap!


2. Сводка советов по избежанию OOM, вызванного Bitmap


1) Используйте метод кодирования с низким потреблением памяти

Как упоминалось в предыдущем разделе,BitmapFactory.OptionsВ этом классе мы можем задать его свойство inPreferredConfig, которое по умолчанию имеет значениеBitmap.Config.ARGB_8888, мы можем изменить его на:Bitmap.Config.ARGB_4444
Bitmap.Config ARGB_4444: каждый пиксель занимает четыре бита, т.е. A=4, R=4, G=4, B=4, поэтому пиксель занимает 4+4+4+4=16 бит
Bitmap.Config ARGB_8888: каждый пиксель занимает восемь бит, т.е. A=8, R=8, G=8, B=8, поэтому пиксель занимает 8+8+8+8=32 бита
По умолчанию используется ARGB_8888, что означает, что один пиксель занимает 4 байта!


2) Сжатие изображения

Всё ещё используя BitmapFactory.Options, можно с помощьюinSampleSizeзадать коэффициент масштабирования. Например, значение 2 означает, что ширина и высота становятся 1/2 от исходных, а изображение — 1/4 от исходного. Если масштабирование не требуется, установите 1. Однако нельзя сжимать бездумно. Ведь если это значение слишком мало, изображение будет очень размытым, и нужно избегать растяжения и искажений. Поэтому нам нужно динамически вычислять подходящее значение inSampleSize в программе. В Options также есть такой метод:inJustDecodeBoundsПосле установки этого параметра в true decodeFile не будет выделять память, но сможет вычислить ширину и высоту исходного изображения. Вызовите options.outWidth/outHeight, чтобы получить ширину и высоту изображения, затем с помощью определённого алгоритма можно получить подходящее значение inSampleSize. СпасибоJie Shenза предоставленный код — выдержка из блога Hongyang!

public static int caculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
    int width = options.outWidth;
    int height = options.outHeight;
    int inSampleSize = 1;
    if (width > reqWidth || height > reqHeight) {
        int widthRadio = Math.round(width * 1.0f / reqWidth);
        int heightRadio = Math.round(height * 1.0f / reqHeight);
        inSampleSize = Math.max(widthRadio, heightRadio);
    }
    return inSampleSize;
}

Затем можно использовать вышеуказанный метод:

BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true; // 设置了此属性一定要记得将值设置为false
Bitmap bitmap = null;
bitmap = BitmapFactory.decodeFile(url, options);
options.inSampleSize = computeSampleSize(options,128,128);
options.inPreferredConfig = Bitmap.Config.ARGB_4444;
/* 下面两个字段需要组合使用 */  
options.inPurgeable = true;
options.inInputShareable = true;
options.inJustDecodeBounds = false;
try {
    bitmap = BitmapFactory.decodeFile(url, options);
} catch (OutOfMemoryError e) {
        Log.e(TAG, "OutOfMemoryError");
}

3. Своевременно освобождайте изображения

Если имеется много ссылок на объекты Bitmap и приложению не нужно отображать все изображения одновременно, можно своевременно вызывать recycle для объектов Bitmap, которые временно не нужны. В некоторых сценариях, где использование изображений точно известно, можно активно вызывать recycle для их освобождения, например изображения на странице руководства: вызывать recycle после использования. Для покадровой анимации: загрузить один, отрисовать один, освободить один! Загружать при использовании, а когда не отображается — сразу установить в null или вызывать recycle! Например: imageView.setImageResource(0); Однако в некоторых случаях возникают неэффективные ситуации вроде повторной загрузки, освобождения и повторной загрузки конкретного изображения...


4. Другие методы

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

1. Простое использование SoftReference для управления ресурсами изображений

Создайте HashMap из SoftReference. При использовании изображения сначала проверьте, есть ли в этом HashMap SoftReference и пусто ли изображение в SoftReference. Если оно пусто, загрузите изображение в SoftReference и добавьте его в HashMap. В коде не нужно явно обрабатывать утилизацию и освобождение изображений; GC автоматически выполнит освобождение ресурсов. Этот метод прост и практичен и может в определенной степени избежать неэффективности повторной загрузки и освобождения в предыдущем методе. Но он недостаточно оптимизирован.

Пример кода:

private Map<String, SoftReference<Bitmap>> imageMap 
                                           = new HashMap<String, SoftReference<Bitmap>>();

public Bitmap loadBitmap(final String imageUrl,final ImageCallBack imageCallBack) {
    SoftReference<Bitmap> reference = imageMap.get(imageUrl);
    if(reference != null) {
        if(reference.get() != null) {
            return reference.get();
        }
    }
    final Handler handler = new Handler() {
        public void handleMessage(final android.os.Message msg) {
            //加入到缓存中
            Bitmap bitmap = (Bitmap)msg.obj;
            imageMap.put(imageUrl, new SoftReference<Bitmap>(bitmap));
            if(imageCallBack != null) {
                imageCallBack.getBitmap(bitmap);
            }
        }
    };
    new Thread(){
        public void run() {
            Message message = handler.obtainMessage();
            message.obj = downloadBitmap(imageUrl);
            handler.sendMessage(message);
        }
    }.start();
    return null ;
}

// 从网上下载图片
private Bitmap downloadBitmap (String imageUrl) {
    Bitmap bitmap = null;
    try {
        bitmap = BitmapFactory.decodeStream(new URL(imageUrl).openStream());
        return bitmap ;
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    } 
}
public interface ImageCallBack{
    void getBitmap(Bitmap bitmap);
}

2. Подход с LruCache + кэшированием на SD-карте

Начиная с Android 3.1, официально предоставляется LruCache для обработки кэша. Когда размер сохранённых изображений превышает значение, заданное LruCache, изображения, к которым дольше всего не обращались, будут утилизированы, и система автоматически освободит память!

Пример использования:

Шаги:

1) Сначала задайте размер памяти для кэшируемых изображений. Здесь я установил его равным 1/8 памяти телефона. Как получить память телефона: int MAXMEMONRY = (int) (Runtime.getRuntime() .maxMemory() / 1024);

2) Пары ключ-значение в LruCache — это URL и соответствующее изображение.

3) Переопределите метод с именем sizeOf, который возвращает количество изображений.

private LruCache<String, Bitmap> mMemoryCache;
private LruCacheUtils() {
    if (mMemoryCache == null)
        mMemoryCache = new LruCache<String, Bitmap>(
                MAXMEMONRY / 8) {
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                // 重写此方法来衡量每张图片的大小,默认返回图片数量。
                return bitmap.getRowBytes() * bitmap.getHeight() / 1024;
            }

            @Override
            protected void entryRemoved(boolean evicted, String key,
                    Bitmap oldValue, Bitmap newValue) {
                Log.v("tag", "hard cache is full , push to soft cache");
               
            }
        };
}

4) Ниже перечислены методы: очистка кэша, добавление изображения в кэш, получение изображения из кэша и удаление изображения из кэша.

Удаление и очистка кэша обязательны, потому что неправильная работа с кэшем изображений приведёт к ошибкам out-of-memory, поэтому нужно обратить на это внимание.

public void clearCache() {
    if (mMemoryCache != null) {
        if (mMemoryCache.size() > 0) {
            Log.d("CacheUtils",
                    "mMemoryCache.size() " + mMemoryCache.size());
            mMemoryCache.evictAll();
            Log.d("CacheUtils", "mMemoryCache.size()" + mMemoryCache.size());
        }
        mMemoryCache = null;
    }
}

public synchronized void addBitmapToMemoryCache(String key, Bitmap bitmap) {
    if (mMemoryCache.get(key) == null) {
        if (key != null && bitmap != null)
            mMemoryCache.put(key, bitmap);
    } else
        Log.w(TAG, "the res is aready exits");
}

public synchronized Bitmap getBitmapFromMemCache(String key) {
    Bitmap bm = mMemoryCache.get(key);
    if (key != null) {
        return bm;
    }
    return null;
}

/**
 * 移除缓存
 * 
 * @param key
 */
public synchronized void removeImageCache(String key) {
    if (key != null) {
        if (mMemoryCache != null) {
            Bitmap bm = mMemoryCache.remove(key);
            if (bm != null)
                bm.recycle();
        }
    }
}

Вышеприведённое содержание взято из —Кэширование изображений: технология кэширования в памяти LruCache, мягкие ссылки


Итоги этого раздела:

В этом разделе мы объяснили причину проблем OOM и обобщили некоторые найденные в интернете решения для избежания OOM, вызванных Bitmap. Поскольку приложения, которые делает моя компания, все связаны с картами и редко включают изображения, автор никогда не сталкивался с проблемами OOM, поэтому я не очень хорошо с этим знаком. Позже, в продвинутом курсе по управлению памятью, мы постепенно разберёмся с этой проблемой OOM. Ладно, на этом этот раздел заканчивается, спасибо.


Ссылки: Анализ и решения проблем OOM в Android-приложениях