1. Что такое OOM?

03-21 21:05:28.771: E/dalvikvm-heap(13316): Out of memory on a 10485776-byte allocation.
03-21 21:05:28.779: E/AndroidRuntime(13316): java.lang.OutOfMemoryError

Эти строки означают, что нашей программе нужно выделить 10485776 bytes, что слишком много, и виртуальная машина не может удовлетворить нас, поэтому она позорно завершает работу и убивает себя. Это явление обычно возникает при разработке APP, которые используют много изображений или очень большие изображения. Проще говоря, когда нашему APP нужно запросить участок памяти для загрузки изображения, система считает, что память, используемая нашим APP, уже слишком велика. Даже если у нее есть 1G свободной памяти, она отказывается дать нашему APP больше памяти; тогда даже несмотря на то, что система немедленно создает ошибку OOM, программа не перехватывает ошибку, поэтому появляется диалоговое окно и происходит сбой.

2. Почему возникает OOM?

Потому что каждый процесс или каждая виртуальная машина системного приложения Android имеет максимальный лимит памяти. Если запрошенные ресурсы памяти превышают этот лимит, система выдаст ошибку OOM. Это мало связано с оставшейся памятью всего устройства. Например, в более ранних системах Android виртуальная машина имела максимум 16M памяти. После запуска приложения виртуальная машина продолжает запрашивать ресурсы памяти для загрузки изображений, и когда она превышает верхний предел памяти, возникает OOM. Как определяется лимит памяти системных приложений Android?

2.1 Состав памяти приложения Android:

Память приложения состоит изпамяти dalvikиnative-памятиОна состоит из двух частей. Dalvik — это куча Java; созданные объекты размещаются здесь, а native — это память, выделяемая через c/c++. Bitmap выделяется таким образом. (После Android 3.0 система по умолчанию выделяет Bitmap через Dalvik, а native управляется как куча.) Сумма этих двух частей не может превышать лимит памяти Android для одного процесса или виртуальной машины.

Каков размер лимита памяти для каждого телефона?

ActivityManager activityManager = (ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE)
activityManager.getMemoryClass();

Приведённый выше метод возвращает число в M (мегабайтах). Значения различаются на разных системных платформах или устройствах, например HTC по умолчанию 24M, Galaxy 36M, emulator-2.3 24M и т. д. Мой Moto XT681 — 42M. 3

Полученное выше — это максимальный ресурс памяти виртуальной машины.

Что касается ограничения размера head heap, можно проверить файл /system/build.prop.

dalvik.vm.heapstartsize  =  5m
dalvik.vm.heapgrowthlimit = 48m
dalvik.vm.heapsize = 256m

Примечание:Параметр heapsize указывает максимальный объём памяти, доступный для кучи одного процесса. Но если существует следующий параметр "dalvik.vm.headgrowthlimit =48m", это означает, что память кучи одного процесса ограничена 48m, то есть программа фактически может использовать только 48m памяти во время своего выполнения.

2.2 Почему система Android устанавливает ограничение памяти для приложений?

1   Чтобы разработчики более рационально использовали память.Ограничение верхнего предела доступной памяти для каждого приложения может предотвратить использование некоторыми приложениями слишком большого объёма памяти злонамеренно или непреднамеренно, из-за чего другие приложения не смогут нормально работать. Android является многопроцессной системой. Если процесс (то есть приложение) потребляет слишком много памяти, другие приложения не могут работать. Из-за этого ограничения разработчики должны эффективно использовать ограниченные ресурсы и оптимизировать их потребление.

2 Экран может отображать ограниченный объём содержимого; достаточно иметь достаточный объём памяти.Даже если есть тысячи изображений и десятки миллионов элементов данных, которые нужно использовать, то, что требуется показать пользователю в конкретный момент, всегда ограничено, потому что экран имеет лишь такой размер, и информации, которую можно на нём разместить, очень мало. Большая часть информации находится в состоянии готовности к отображению, поэтому нет необходимости выделять слишком много памяти кучи. Иными словами, когдаВозникает явление OOM; в большинстве случаев причины в том, что в нашем дизайне программы есть проблемы и требуется оптимизация.Существует множество методов оптимизации, например обмен времени на пространство: непрерывная загрузка используемых изображений, непрерывное освобождение неиспользуемых изображений, декодирование больших изображений в изображения, подходящие для размера экрана телефона, и т. д.

3   Необходимость ограничения множества приложений и множества виртуальных машин Dalvik.Приложения на Android используют независимые виртуальные машины; каждый раз при открытии приложения запускается как минимум одна независимая виртуальная машина. Это предотвращает падение всей системы из-за сбоя виртуальной машины, ценой является расход большего объёма памяти. Такое решение обеспечивает стабильность Android.

2.3 Разве GC не автоматически освобождает ресурсы? Почему всё равно возникает OOM?

Разве Android не использует GC для автоматического освобождения ресурсов? Почему не освобождаются те неиспользуемые ресурсы в приложении?

GC в Android освобождает неиспользуемые ресурсы памяти по определённым алгоритмам, не позволяя запросам памяти приложения накапливаться всё больше и больше. Однако GC обычно освобождает такие ресурсы, как память объектов без ссылок или ресурсы с мягкими ссылками, или даже ресурсы с более слабыми ссылками. Например:

Bitmap bt = BitmapFactory.decodeResource( this .getResources(), R.drawable.splash);  //此时的图片资源是强引用,是有主的资源。
bt =  null ;  //此时这个图片资源就是无主的了。gc心情号的时候就会去回收它。
SoftReference<Bitmap> softRef =  new  SoftReference<Bitmap>(bt);
bt =  null ;
其他代码...

Когда программа запрашивает много ресурсов памяти, GC может освободить память изображения, на которую ссылается softRef. Тогда bt = softRef.get() может вернуть null, поэтому изображение нужно загрузить заново.

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

СОВЕТ: выработайте привычку присваивать неиспользуемым объектам null при программировании. На самом деле даже лучше напрямую освобождать неиспользуемые изображения. Потому что позволять GC освобождать их через присваивание null иногда может быть слишком поздно.

2.4 Как проверить состояние распределения памяти приложения?

1. Отслеживайте состояние памяти через вкладку heap в DDMS:

В середине представления Heap есть нечто под названием "data object", то есть объекты данных, которые являются объектами классового типа, присутствующими в большом количестве в нашей программе.

В строке для data object есть столбец "Total Size", значение которого — общий объём памяти всех Java-объектов данных в текущем процессе. Если в коде возникает ситуация, когда ссылки на объекты не освобождаются, значение "Total Size" для data object не будет показывать заметного снижения после каждого GC. По мере увеличения числа операций значение "Total Size" будет становиться всё больше и больше, пока не достигнет верхнего предела и процесс не будет убит.

2. Внутри приложения мы можем использовать totalMemory и freeMemory:

Runtime.getRuntime().freeMemory()
RUntime.getRuntime().totalMemory()

3 adb shell dumpsys meminfo com.android.demo

3. Несколько моментов, которые следует учитывать для избежания OOM:

3.1 Правильно подбирайте размер изображения. Поскольку размер экрана телефона ограничен, область отображения, выделяемая изображениям, ограничена, особенно для сверхбольших изображений, загружаемых из сети или с SD-карты, где размер файла изображения достигает нескольких MB или более десятка MB:

Перед загрузкой в память сначала вычислите размер bitmap, затем соответствующим образом скорректируйте частоту сэмплирования, чтобы загруженное изображение было как раз нужного размера или немного больше и достаточно для отображения на экране телефона.

BimtapFactory.Option opts =  new   BitampFactory.Option();
        opts.inJustDecodeBounds =  true ;
        opts.inSampleSize=computeSample(opts, minSideLength, maxNumOfPixels);  // Android 提供了一种动态计算的方法 computeSampleSize
        opts.inJustDecodeBounds =  false ;
         try {
                return  BitmapFactory.decodeFile(imageFile, opts);
        }  catch (OutOfMemoryError err){
}

3.2 Кэширование изображений. При одновременной загрузке большого количества изображений в таких элементах управления, как ListView или Gallery, загружайте только ресурсы, отображаемые на экране, не загружайте ещё не отображаемые и своевременно освобождайте ресурсы, уходящие за пределы экрана. Используйте двухуровневый кэш из сильной ссылки + мягкой ссылки для повышения производительности загрузки. Кэшируйте изображения в памяти с помощью мягких ссылок, вместо того чтобы перезагружать их в память при каждом использовании.

3.3 Используйте методы кодирования с меньшим потреблением памяти. Например, Bitmap.Config.ARGB_4444 использует меньше памяти, чем Bitmap.Config.ARGB_8888.

3.4 Своевременно освобождайте изображения. Если существует много ссылок на объекты Bitmap и приложение не нуждается в одновременном отображении всех изображений, можно своевременно освобождать временно неиспользуемые объекты Bitmap. В некоторых сценариях, где статус использования изображений точно известен, можно активно вызывать recycle для их освобождения.

Для ресурсов изображений на заставке при запуске приложения освобождайте их после использования. Для покадровых анимаций можно загружать один, отрисовывать один и освобождать один.

3.5 Не создавайте слишком много локальных переменных в циклах. Используйте static с осторожностью. Когда static используется для изменения переменной-члена, переменная принадлежит классу, а не экземпляру класса, и её жизненный цикл очень долгий. Если с его помощью ссылаться на экземпляры, которые занимают слишком много памяти, нужно быть осторожным.

3.6 Настройте размер выделения памяти в куче. Оптимизируйте выделение памяти в куче виртуальной машины Dalvik.

public   class  ClassName{
    private   static  Context mContext;
       // 省略
}

4. Несколько способов избежать OOM, когда приложение использует изображения:

4.1  Непосредственно установить в null или recycle

Для большого количества изображений, используемых в приложении, применяйте такой подход: загружайте их при использовании и устанавливайте в null или вызывайте recycle для них, когда они не отображаются.

Это хорошая привычка, и она в основном позволяет избавиться от OOM, но недостаток в том, что кода становится больше, и вы можете забыть вызвать recycle для некоторых ресурсов.

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

4.2 Простое управление ресурсами изображений через ссылки SoftReference

Создайте HashMap из SoftReference

При использовании изображения сначала проверьте, есть ли в hashmap softreference и является ли изображение в softreference значением null.

Если оно равно null, загрузите изображение в softreference и добавьте его в hashmap.

Нет необходимости явно управлять утилизацией и освобождением изображений в коде; GC автоматически выполнит освобождение ресурсов.

Этот метод прост и практичен в использовании и позволяет в некоторой степени избежать неэффективности повторной загрузки и освобождения, присущей предыдущему методу. Но он недостаточно оптимизирован.

4.3 Двухуровневый кэш: сильная ссылка + мягкая ссылка

Демонстрационная программа Android ImageDownloader.java использует механизм двухуровневого кэша. То есть существует структура данных, которая напрямую хранит ссылки на успешно декодированные объекты Bitmap, тогда как структура данных второго уровня кэша хранит объекты мягких ссылок на вытесненные Bitmap. Из-за особой природы объектов мягких ссылок, когда требуется память, система сначала освободит объекты, удерживаемые мягкими ссылками. То есть, когда VM обнаруживает, что доступной памяти мало и необходимо запустить GC, объекты bitmap во втором уровне кэша будут утилизированы, а объекты bitmap, удерживаемые первым уровнем кэша, используются для отображения.

На самом деле, наиболее критичным моментом этого решения является использование относительно подходящей структуры данных, а именно типа LinkedHashMap в качестве контейнера для кэша первого уровня Bitmap. Благодаря особенностям LinkedHashMap мы можем контролировать количество объектов, хранящихся в памяти, и удалять неиспользуемые объекты из контейнера, помещая их в кэш второго уровня на SoftReference. Мы всегда можем хранить самые недавно использованные объекты Bitmap в кэше первого уровня. Когда емкость LinkedHashMap превышает наше заданное значение, объекты, которые находились в контейнере дольше всего, будут удалены. В этот момент мы можем поместить удаленные объекты из LinkedHashMap в контейнер кэша второго уровня, а управление объектами в кэше второго уровня оставить системе. Когда системе потребуется GC, она сначала переработает объекты Bitmap в контейнере кэша второго уровня.

При получении объекта изображения сначала выполняется поиск в контейнере кэша первого уровня. Если соответствующий объект есть и он доступен, вернуть его напрямую. Если нет, выполняется поиск соответствующего SoftReference в кэше второго уровня, определяется, доступен ли Bitmap, удерживаемый объектом SoftReference; если доступен, вернуть его напрямую, иначе вернуть null. Если изображение не найдено и в кэше второго уровня, то напрямую загрузить ресурс изображения.

4. Метод кэширования LruCache + SD-карта

5. Рекомендации для двух сценариев, склонных к OOM:

5.1 Загрузка большого количества изображений по сети

Например, клиент Weibo: многопоточная асинхронная сеть, небольшие изображения напрямую используют LRUCache+SoftRef+SD, большие изображения загружаются по требованию:

   

5.2 Для случаев, таких как ListView, GridView, которым требуется загружать очень большое количество элементов списка

В функции getView адаптера есть параметр convertView, который сообщает, существует ли повторно используемый объект представления. Если convertView не используется, каждый вызов getView будет создавать новое представление. Таким образом, предыдущее представление может быть еще не уничтожено, и непрерывное создание новых представлений неизбежно вызовет резкий рост памяти, что приведет к OOM. Кроме того, при повторном использовании convertView исходные изображения и другие ресурсы внутри него становятся бесхозными.

Здесь Google официально рекомендует использовать: "convertView + static class ViewHolder"

Официальное объяснение:

a. Повторно используйте кэшированный convertView, передаваемый в метод getView(), чтобы избежать раздувания ненужных представлений.

b. Используйте паттерн ViewHolder, чтобы избежать ненужных вызовов findViewById(); поскольку слишком много вызовов findViewById() также влияет на производительность.

 

Дополнительное пояснение роли класса ViewHolder: паттерн ViewHolder сохраняет структуру данных в теге представления, возвращаемого методом getView. Эта структура данных содержит ссылки на представления, к которым мы хотим привязать данные, тем самым избегая вызова findViewById() при каждом вызове getView().

6. Как запросить выделение памяти, превышающее лимит памяти:

6.1 Выделение памяти из Native C. Используя NDK (Native Development Kit) и JNI, можно выделять память на уровне C (например, malloc/free или new/delete). Такое выделение не учитывается в лимите 24MB. Это верно; выделение памяти из нативного кода служит для удобства Java, но его можно в некоторой степени использовать для хранения данных в RAM (даже данных изображений).

6.2 Используйте текстуры OpenGL. Память под текстуры не учитывается в лимите. Чтобы проверить, сколько памяти ваше приложение фактически выделило, можно использовать android.os.Debug.getNativeHeapAllocatedSize(). На одном из устройств Nexus, используя две вышеописанные техники, я могу легко выделить 300MB для одного процесса переднего плана — более чем в 10 раз больше стандартного лимита 24MB. Из вышесказанного следует, что использование нативного кода для выделения памяти не ограничивается лимитом 24MB (текстуры OpenGL также используют нативный код для выделения памяти).

Однако риск этих двух методов заключается в том, что если нативная куча выделяет больше памяти, чем доступный лимит памяти системы, это обычно приводит к немедленному сбою.