ГлавнаяОптимизацияОптимизация системной памяти для разработчиков

Закончилась память в смартфоне? Простые советы по оптимизации. Оптимизация системной памяти для разработчиков


Устройство медленно работает? Попробуйте оптимизацию памяти! - Инструкции - Mi Community

Cover Image

click to edit

* Recommended to upload a 720*312 image as the cover image

Article Description

Привет, Mi фаны!Данная тема представляет собой перевод рубрики на английском форуме MIUI.В: Почему мое устройство работает медленно? О: Иногда ваши файлы и приложения занимают много памяти. Как в активном, так и в неактивном состоянии они используют огромное количество ресурсов, включая и оперативную память, в связи с чем для вашего устройства требуется больше времени для запуска - он начинает работать медленнее, а иногда вовсе начинает выдавать ошибки. В MIUI есть отличное решение - Оптимизация системной памяти! Основная теория данной функции следующая: она сжимает неактивные файлы, после чего они используют меньше места. Однако сжатые файлы требуют больше времени для их обработки. Поэтому вы должны решить для себя, использовать ли оптимизацию системной памяти. Если на вашем устройстве мало оперативной памяти, в таком случае рекомендуется включить оптимизацию на средний или низкий уровень, и вы заметите значительную разницу в скорости работы. Но если на вашем устройстве достаточно ОЗУ, вы можете полностью отключить эту функцию, тем самым снизить нагрузку, используемую на обработку файлов в оперативной памяти.Что нужно сделать: 1) Активируйте настройки для разработчиков. Для этого зайдите в Настройки  Об устройстве  и быстро нажмите 6-7 раз на пункт Версия MIUI, после чего должно появиться всплывающее уведомление об успешной активации.2) Понизьте или отключите оптимизацию. Зайдите в Настройки  Дополнительно  Для разработчиков  Оптимизация памяти.3) Перезагрузите устройствоИсточник

Select Column

Add to Column

* Changes are irreversible after submitting

c.mi.com

Управление памятью вашего приложения | Учебный курс по разработке Android приложений

Оперативная память (RAM) является ценным ресурсом в любой среде разработки программного обеспечения, но это еще более ценным на мобильной операционной системы, где физическая память часто ограничена. Не смотря на то, что виртуальная машина Android Dalvik, выполняет рутинный сбор мусора, это не позволяет вам игнорировать, когда и где ваше приложение выделяет и освобождает память.

Для того, чтобы сборщик мусора смог вернуть память из вашего приложения, вам нужно избегать утечек памяти (обычно вызванные удержанием ссылок на объекты в глобальных членах классов) и освободить все Reference объекты в соответствующее время (как определено жизненным циклом обратных вызовов, обсуждаемым ниже). Для большинства приложений, сборщик мусора Dalvik заботится об остальном: система освобождает выделения памяти, когда соответствующие объекты выходят за рамки активных потоков вашего приложения.

Этот документ объясняет, как Android управляет процессами приложений и выделением памяти, и как вы можете активно уменьшить использование памяти при разработке для Android. Дополнительные сведения об общей практики по очистке своих ресурсов при программировании на Java, обратитесь к другим книгам или онлайн документации об управлении ссылками на ресурсы. Если вы ищете информацию о том, как анализировать память вашего приложения, как только вы собрали его, читайте Исследование использования оперативной памяти.

Как Android управляет памятью

Android не предоставляет подкачку для памяти, но используется подкачка страниц и отображение файла в память (mmapping) для управления памятью. Это означает, что любое изменение памяти, путем выделения новых объектов, или касающиеся файлов с отображением в память — прежнему находится в оперативной памяти и не может быть выгружено. Поэтому единственным способом полностью освободить память вашего приложения является освобождение ссылок на объекты, которые вы возможно храните, позволив сборщику мусора освободить память. За одним исключением: любые файлы с отображением в память без изменений, такие как код, могут быть выгружены из памяти, если система захочет использовать эту память в другом месте.

Общая память

Чтобы вместить всё необходимое в оперативной памяти, Android пытается совместно использовать страницы оперативной памяти между процессам. Он может делать это одним из следующих способов:

В связи с широким использованием общей памяти, определение того, сколько памяти ваше приложение использует, требуется особого внимания. Методы для правильного определения использования памяти в вашем приложении обсуждаются в статье Исследование использования оперативной памяти.

Выделение и освобождение памяти приложения

Вот некоторые факты о том, как Android выделяет и затем освобождает память вашего приложения:

Ограничение памяти приложения

Для поддержания функциональной среды многозадачности, Android устанавливает жесткий лимит на размер кучи для каждого приложения. Точный предельный размер кучи колеблется для устройств, в зависимости от размера оперативной памяти устройства в наличии в целом. Если ваше приложение достигло максимально допустимого размера кучи, и пытается выделить больше памяти, оно получит OutOfMemoryError.

В некоторых случаях, вы можете запросить у системы точный размер кучи, имеющийся в наличии на данном устройстве — например, чтобы определить сколько данных безопасно держать в кэше. Вы можете запросить у системы вызвав метод getMemoryClass(). Он возвращает целое число, указывающее количество мегабайт доступных для кучи вашего приложения. Дальнейшее обсуждение ниже в разделе Проверьте, сколько памяти вы должны использовать.

Переключение приложений

Вместо того чтобы использовать подкачку памяти, когда пользователь переключается между приложениями, Android сохраняет процессы, которые не находятся на переднем плане ("видимые пользователю"), в кэш-памяти для недавно использованных приложений. Например, когда пользователь впервые запускает приложение, для него создается процесс, но когда пользователь выходит из приложения, этот процесс не завершается. Система сохраняет процесс в кэше, поэтому если пользователь позже возвращается в приложение, процесс повторно используется для быстрого переключения приложений.

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

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

Как ваше приложение должно управлять памятью

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

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

Используйте службы экономно

Если вашему приложению необходима служба для выполнения работ в фоновом режиме, не оставляйте её работать, если она не выполняет какую-либо работу. Также будьте осторожны, избегайте утечек ваших служб при ошибках остановки служб, когда работа сделана.

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

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

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

Освободите память, когда ваш пользовательский интерфейс становится невидимым

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

Чтобы получать уведомления, когда пользователь выходит из пользовательского интерфейса, реализуйте onTrimMemory() метод обратного вызова в ваших Activity классах. Вы должны использовать этот метод для прослушивания TRIM_MEMORY_UI_HIDDEN уровня, который указывает на то, что пользовательский интерфейс теперь скрыт, и вы должны освободить ресурсы, которые используются только вашим пользовательским интерфейсом.

Обратите внимание, что ваше приложение получает onTrimMemory() обратный вызов с TRIM_MEMORY_UI_HIDDEN только тогда, когда все компоненты пользовательского интерфейса вашего процесса приложения становятся скрытыми от пользователя. Этим он отличается от onStop() обратного вызова, который вызывается когда Activity становится скрытой, даже в случае когда пользователь перемещается на другую деятельность в вашем приложении. Таким образом, хотя вы должны реализовать onStop() для освобождения ресурсов деятельности, таких как подключение к сети или для отмены регистрации широковещательных приемников, вы, как правило, не должны освобождать свои ресурсы пользовательского интерфейса, пока вы не получите onTrimMemory(TRIM_MEMORY_UI_HIDDEN). Это гарантирует, что если пользователь переходит назад из другой деятельности в вашем приложении, ваши ресурсы пользовательского интерфейса по-прежнему доступны для быстрого возобновления деятельности.

Освободите память, когда памяти становится недостаточно

Во время любой стадии жизненного цикла вашего приложения, onTrimMemory() метод обратного вызова также сообщает вам, когда общая память устройства становится низкой. Вы должны реагировать путем дальнейшего высвобождения ресурсов на основе следующих уровней памяти, передаваемых в onTrimMemory():

Кроме того, когда ваш процесс приложение в настоящее время в кэше, вы может получить один из следующих уровней в onTrimMemory():

Поскольку onTrimMemory() метод обратного вызова был добавлен в уровне API 14, вы можете использовать onLowMemory() метод обратного вызова в качестве запасного варианта для более старых версий, который примерно эквивалентен TRIM_MEMORY_COMPLETE событию.

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

Проверьте, сколько памяти вы должны использовать

Как упоминалось ранее, каждое Android-устройство имеет различное количество доступной оперативной памяти в системе, и, таким образом, предоставляет разные ограничения кучи для каждого приложения. Вы можете вызвать getMemoryClass() чтобы получить оценку имеющейся кучи вашего приложения в мегабайтах. Если ваше приложение пытается выделить больше памяти, чем доступно здесь, оно будет получать OutOfMemoryError.

В особых ситуациях, вы можете запросить больший размер кучи, установив largeHeap атрибут в "true" в манифесте <application> тег. Если вы это сделаете, вы можете вызвать getLargeMemoryClass() для получения оценки кучи большого размера.

Однако способность просить большую кучу предназначена только для небольшого набора приложений, которые могут оправдать необходимость потреблять больше оперативной памяти (например, большое приложение для редактирования фотографий). Никогда не просите большую кучу просто потому, что вы получили ошибку о нехватке памяти, и вам нужно быстро исправить — вы должны использовать его только тогда, когда вы точно знаете, где вся ваша выделенная память, и почему так и должно оставаться. Тем не менее, даже когда вы уверены, что ваше приложение может оправдать большую кучу, вам следует избегать такого запроса. Использование дополнительной памяти будет всё больше и больше приносить ущерб общему впечатлению пользователя, поскольку сборка мусора займет больше времени и производительность системы может замедлиться при переключении задач или выполнении других распространенных операций.

Кроме того, большой размер кучи не одинаковый на всех устройствах, и, при работе на устройствах, которые имеют ограничение оперативной памяти, большой размер кучи может быть точно таким же, как обычный размер кучи. Таким образом, даже если вы запросили большой размер кучи, вам следует вызвать getMemoryClass() для проверки обычного размера кучи, и стремиться всегда оставаться ниже этого предела.

Избегайте загрязнения памяти растровыми изображениями

При загрузке растрового изображения, держите его в памяти только в том разрешении, которое необходимо для экрана текущего устройства, масштабируйте его вниз, если исходное растровое изображение большего разрешения. Имейте в виду, что увеличение разрешения растровых изображений, приводит к соответствующему (увеличению2) необходимой памяти, потому что увеличиваются оба размера X и Y.

Примечание: На Android 2.3.x (API Уровень 10) и ниже, объекты растровых изображений всегда одного и того же размера в вашей куче приложения независимо от разрешения изображения (фактические данные пикселей хранится отдельно в аппаратной памяти). Это делает более трудной отладку памяти растровых изображений, потому что большинство инструментов анализа кучи не видит распределения аппаратной памяти. Однако, начиная с Android 3.0 (API Уровень 11), данные точек растрового изображения выделяются в Dalvik куче вашего приложения, улучшая сборку мусора и способность отладки. Так что если ваше приложение использует растровые изображения, и у вас возникли проблемы обнаружения почему ваше приложение использует некоторое количество памяти на старом устройстве, переключитесь на устройства под управлением Android 3.0 или выше, чтобы ее отладить.

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

Используйте оптимизированные контейнеры данных

Воспользуйтесь оптимизированными контейнерами для Android, такими как SparseArray, SparseBooleanArray, и LongSparseArray. В шаблонной реализации HashMap память может использоваться довольно неэффективно, потому что ей необходим отдельный объект для хранения для каждого элемента. Кроме того, SparseArray классы являются более эффективными, поскольку они исключают необходимость системы к преобразованию типов (называемых autobox ) для ключей и иногда значений (что создает еще один или два объекта для каждого элемента). И не бойтесь прибегать к обычным массивам, когда в этом есть смысл.

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

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

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

Будьте осторожны с абстрактным кодом

Часто разработчики используют абстракции просто как «хорошую практику программирования", поскольку абстракции могут создать гибкость и улучшить поддержку кода. Тем не менее, абстракции вносят существенные затраты: как правило, они требуют намного больше кода, который должен быть выполнен, требуя больше времени и больше оперативной памяти для этого кода, который будет отображен в память. Так что, если ваши абстракции не предоставляют значительное преимущество, вы должны избегать их.

Используйте nano protobufs для сериализации данных

Protocol buffers это нейтральный от языка и от платформы, расширяемый механизм разработанный Google для сериализации структурированных данных — думайте о XML, но меньше, быстрее, и проще. Если вы решите использовать protobufs для ваших данных, вы всегда должны использовать nano protobufs в вашем клиентского коде. Обычные protobufs генерируют чрезвычайно подробный код, который будет вызывать много разных проблем в вашем приложении: дополнительное использование оперативной памяти, значительное увеличение размера APK, более медленное выполнения, и быстро достижение ограничения символов DEX.

Для получения дополнительной информации см. в разделе "Nano version" в protobuf readme.

Избегайте библиотек внедрения зависимостей

Использование библиотек внедрения зависимостей, таких как Guice или RoboGuice может быть привлекательными, потому что они могут упростить код, который вы пишете, и обеспечить адаптивную среду, которая полезна для тестирования и других изменений конфигурации. Тем не менее, эти библиотеки, как правило, выполняют выполняют инициализацию процесса путем сканирования кода для аннотаций, которая может требовать значительных объемов кода, который будет загружен в память, даже если вы в нем не нуждаетесь. Эти страницы отображений классов загружаются в чистую память, поэтому Android может выгрузить их, но этого не произойдет, пока страницы не останутся в памяти в течение длительного периода времени.

Будьте осторожны при использовании внешних библиотек

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

Даже библиотеки якобы предназначенные для использования на Android являются потенциально опасными, потому что каждая библиотека может действовать по-другому. Например, одна библиотека может использовать nano protobufs, а другая использует micro protobufs. Теперь у вас есть две различные реализации protobuf в своем приложении. Это может и даже будет происходить с различными реализациями записи в журналы, аналитикой, библиотеками загрузка изображений, кэшированием, и всех других вещей, которые вы не ожидаете. ProGuard не спасет вас здесь, потому что они все будут иметь зависимости более низкого уровня, которые требуются функциональности для которой вы используете библиотеку. Это становится особенно проблематичным, когда вы используете Activity подкласс из библиотеки (которая, как правило, имеет широкий ряд зависимостей), когда библиотеки используют reflection (который является общим и означает, что вы должны тратить много времени вручную для настройки ProGuard, чтобы заставить его работать), и так далее.

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

Оптимизация общей производительности

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

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

Используйте ProGuard для удаления ненужного кода

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

Используйте zipalign для заключительного APK

Если вы делаете какую либо завершающую обработку APK созданного системой сборки (в том числе подписание вашим сертификатом), то вы должны выполнить zipalign на нем для его выравнивания. Несоблюдение этого требования может привести к тому, что ваше приложение потребует значительно больше оперативной памяти, потому что такие вещи, как ресурсы не смогут больше быть отображены из APK в память.

Примечание: Google Play не принимает APK файлы, которые не выровнены.

Проанализируйте свое использование оперативной памяти

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

Использование нескольких процессов

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

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

Вы можете задать отдельный процесс для каждого компонента приложения, объявив android:process атрибут для каждого компонента в файле манифеста. Например, можно указать, что ваша служба должна работать в процессе, отдельном от основного процесса вашего приложения, объявив новый процесс с именем "background" (но вы можете назвать процесс как угодно):

<service android:name=".PlaybackService" android:process=":background" />

Ваше имя процесса должно начинаться с двоеточия (':'), чтобы гарантировать, что процесс остается приватным для вашего приложения.

Прежде чем вы решите создать новый процесс, необходимо понять последствия относительно памяти. Для иллюстрации последствий каждого процесса, будем считать, что пустой процесс не делающий в основном ничего, имеет дополнительный объем памяти около 1.4MB, как показано с помощью информации дампа памяти ниже.

adb shell dumpsys meminfo com.example.android.apis:empty ** MEMINFO in pid 10172 [com.example.android.apis:empty] ** Pss Pss Shared Private Shared Private Heap Heap Heap Total Clean Dirty Dirty Clean Clean Size Alloc Free ------ ------ ------ ------ ------ ------ ------ ------ ------ Native Heap 0 0 0 0 0 0 1864 1800 63 Dalvik Heap 764 0 5228 316 0 0 5584 5499 85 Dalvik Other 619 0 3784 448 0 0 Stack 28 0 8 28 0 0 Other dev 4 0 12 0 0 4 .so mmap 287 0 2840 212 972 0 .apk mmap 54 0 0 0 136 0 .dex mmap 250 148 0 0 3704 148 Other mmap 8 0 8 8 20 0 Unknown 403 0 600 380 0 0 TOTAL 2417 148 12480 1392 4832 152 7448 7299 148

Примечание: Более подробная информация о том, как читать такие таблицы, предоставлена в разделе Исследование использования оперативной памяти. Ключевыми данными здесь являются Private Dirty и Private Clean память, которые показывают, что этот процесс, использует практически 1.4Мб невыгружаемой памяти (распределенной по куче Dalvik, аппаратные выделения, загрузки библиотек), и еще 150Кб оперативной памяти для кода, который был отображен в память для выполнения.

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

** MEMINFO in pid 10226 [com.example.android.helloactivity] ** Pss Pss Shared Private Shared Private Heap Heap Heap Total Clean Dirty Dirty Clean Clean Size Alloc Free ------ ------ ------ ------ ------ ------ ------ ------ ------ Native Heap 0 0 0 0 0 0 3000 2951 48 Dalvik Heap 1074 0 4928 776 0 0 5744 5658 86 Dalvik Other 802 0 3612 664 0 0 Stack 28 0 8 28 0 0 Ashmem 6 0 16 0 0 0 Other dev 108 0 24 104 0 4 .so mmap 2166 0 2824 1828 3756 0 .apk mmap 48 0 0 0 632 0 .ttf mmap 3 0 0 0 24 0 .dex mmap 292 4 0 0 5672 4 Other mmap 10 0 8 8 68 0 Unknown 632 0 412 624 0 0 TOTAL 5169 4 11832 4032 10152 8 8744 8609 134

Процесс в настоящее время почти в три раза больше, до 4 Мб, просто показав текст в пользовательском интерфейсе. Это приводит к важному выводу: если вы собираетесь разделить ваше приложение на несколько процессов, только один процесс должен нести ответственность за пользовательский интерфейс. Другие процессы должны избегать любого пользовательского интерфейса, так как это быстро увеличит объем оперативной памяти, необходимый для процесса (особенно как только вы начинаете загружать растровые изображения и другие ресурсы). Затем, может быть трудно или невозможно уменьшить использование памяти после того, как пользовательский интерфейс был отрисован.

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

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

developer-android.unlimited-translate.org

Закончилась память в смартфоне? Простые советы по оптимизации

Стоимость старших моделей смартфонов завышена. Все мы прекрасно понимаем, что разница в цене между 16 ГБ и 32+ ГБ моделями неоправданно большая. Речь идёт и о iPhone, и о всём многообразии флагманских представителей Android. В итоге человек берёт младшую модель с 16 гигабайтами хранилища на борту в надежде, что этого хватит. Но, зачастую реальность не оправдывает его ожидания.

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

Что съедает память в смартфоне

Для начала нужно понять, что указанный производителем объём памяти в устройстве — это не то же самое, что доступный пользователю объём памяти. То есть, на практике нам всегда доступно меньше памяти, чем написано на упаковке, и это справедливо как для iPhone, так и для семейства Android.

В обоих случаях операционная система устройства занимает 2-3 ГБ памяти, и вернуть их в распоряжение пользователя нельзя — эта пространство нужно для работы устройства.

Поэтому, когда вы подыскиваете новый смартфон, то считайте так: 16 ГБ на самом деле примерно равно 13 ГБ, а 32 ГБ — это в лучшем случае 29-30 ГБ.

В дальнейшем на оставшийся пользователю объём памяти будут посягать устанавливаемые приложения и игры. Экраны всё лучше, картинка должна быть всё качественнее, графика всё круче — это серьёзно утяжеляет приложения.

Кроме того, со временем установленные приложения будут толстеть, накапливая в памяти данные кэша — это всё, что остаётся в устройстве в процессе работы приложения и после его закрытия. Любое приложение, получающее контент из Сети, сохраняет его на устройстве для более оперативного предоставления пользователю. Смотрите YouTube — получаете кэшированные видеозаписи. Слушаете музыку онлайн — она кэшируется локально. Сёрфите в Интернете через Chrome — посещённые в браузере странички кэшируются.

Если у вас Android и вы оказались в ситуации, когда срочно нужно получить несколько сотен мегабайт места под видео или фото, то очистите данные кэша.

Настройки -> Память -> тап на Данные кэша.

Также можно выборочно очистить кэш у отдельных приложений.

Настройки -> Приложения -> тап по толстому приложению -> Очистить кэш.

В iOS таких штатных средств нет, но есть сторонние утилиты.

В наши дни 1 ГБ для одной игры уже кажется вполне приемлемым. Периодическая чистка игр с предварительным вопросом к самому себе «буду ли я в это ещё играть?» поможет избавиться от надоевших и ненужных игрушек, которые продолжают занимать порядочное количество памяти. Это же справедливо для любых других приложений. Не понравилось приложение? Не планируете пользоваться им в будущем? Удалите его, не держите просто так на устройстве.

Загружаемая пользователем в устройство музыка становится всё качественнее. Некоторые уже не воспринимают 320 кбит mp3 и хотят только flac. Такие треки занимают в несколько раз больше места на устройстве.

Подумайте, обеспечат ли используемые вами наушники достаточное качество воспроизведения звука, чтобы вы почувствовали разницу? Быть может, mp3 среднего качества вполне хватит?

Если речь идёт о фото и видео, то всё ещё хуже. В топовые актуальные смартфоны ставят 8+ мегапиксельные камеры, которые умеют снимать FullHD видео с высоким фреймрейтом и делать фото очень большого разрешения. Такие фото и видео занимают очень много места. Для примера, 1 час видео в качестве 1080p может занять на вашем смартфоне 10 ГБ места.

С отснятыми видео вариантов фактически нет. Их нужно периодически перемещать из мобильного устройства на компьютер для последующего хранения или размещения на видео-хостинге.

С хранением фотографий может помочь мобильное приложение Dropbox — в нём есть функция автоматического переноса снимков из памяти устройства в облако.

И всё же, чем более технологичными становятся наши мобильные устройства, тем больше будет требоваться места под приложения и контент. Производители понимают это, и зачастую идут навстречу пользователю, встраивая в смартфоны и планшеты слот под съёмные карты памяти. К сожалению, пользователи iPhone, гуглофонов и некоторых других линеек Android лишены такого преимущества. Google предлагает нам хранить все данные в Сети.

Такую концепцию поддерживают и многие разработчики — сейчас нам доступны сотни тематических онлайн-сервисов, предоставляющих контент в виде потоковой передачи. Их дополняют десятки облачных хранилищ. В таком случае память устройства будет забиваться значительно меньше, но значительно возрастают требования к качеству и скорости мобильного Интернета.

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

lifehacker.ru

Prostoy-Site | Все права защищены © 2018 | Карта сайта