Основы сборки мусора

Статья
2023-04-08

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

В этой статье описаны основные понятия сборки мусора.

Льготы

Использование сборщика мусора обеспечивает следующие преимущества:

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

Основы работы с памятью

В следующем списке приведены важные понятия памяти СРЕДЫ CLR:

Каждый процесс имеет свое собственное отдельное виртуальное адресное пространство. Все процессы на одном компьютере используют одну и ту же физическую память и файл страницы, если есть один.
По умолчанию на 32-разрядных компьютерах каждому процессу выделяется 2 Гбайт виртуального адресного пространства в пользовательском режиме.
Разработчики приложений работают только с виртуальным адресным пространством и никогда не управляют физической памятью напрямую. Сборщик мусора выделяет и освобождает виртуальную память для разработчика в управляемой куче.

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

Виртуальная память может находиться в трех состояниях.

State	Description
Бесплатно	Ссылки на блок памяти отсутствуют, и он доступен для выделения.
Зарезервировано	Блок памяти доступен для использования и не может использоваться для любого другого запроса на выделение. Однако вы не можете хранить данные в этом блоке памяти, пока не будет зафиксировано.
Зафиксировано	Блок памяти назначен физическому хранилищу.

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

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

Выделение памяти

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

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

Освобождение памяти

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

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

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

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

Условия для сборки мусора

Сборка мусора возникает при выполнении одного из следующих условий:

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

Управляемая куча

После инициализации сборщика мусора среда CLR выделяет сегмент памяти для хранения объектов и управления ими. Эта память называется управляемой кучей в отличие от собственной кучи операционной системы.

Для каждого управляемого процесса существует управляемая куча. Все потоки в процессе выделяют память для объектов в одной и той же куче.

Для резервирования памяти сборщик мусора вызывает функцию Windows VirtualAlloc и резервирует для управляемых приложений по одному сегменту памяти за раз. Сборщик мусора также резервирует сегменты по мере необходимости и освобождает сегменты обратно в операционную систему (после очистки всех объектов), вызывая функцию Windows VirtualFree .

Внимание

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

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

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

Степень вмешательства (частота и длительность) сборок мусора зависит от числа распределений и сохранившейся в управляемой куче памяти.

Кучу можно рассматривать как совокупность двух куч: куча больших объектов и куча маленьких объектов. Куча больших объектов содержит объекты размером от 85 000 байтов, обычно представленные массивами. Это редко для объекта экземпляра, который должен быть большим.

Совет

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

Поколения

Алгоритм сборки мусора учитывает следующее:

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

Сборка мусора в основном сводится к уничтожению короткоживущих объектов с небольшим временем жизни. Для оптимизации производительности сборщика мусора управляемая куча делится на три поколения: 0, 1 и 2. Следовательно, объекты с большим и небольшим временем жизни обрабатываются отдельно. Сборщик мусора хранит новые объекты в поколении 0. Уровень объектов, созданных на раннем этапе работы приложения и оставшихся после сборок мусора, повышается, и они сохраняются в поколении 1 и 2. Так как сжать часть управляемой кучи быстрее, чем всю кучу, эта схема позволяет сборщику мусора освобождать память в определенном поколении, а не для всей кучи при каждой сборке мусора.

Поколение 0: это поколение является самым молодым и содержит кратковременные объекты. Примером короткоживущего объекта является временная переменная. Сборка мусора чаще всего выполняется в этом поколении.

Вновь распределенные объекты образуют новое поколение объектов и неявно являются сборками поколения 0. Тем не менее, если они являются большими объектами, они идут на кучу больших объектов (LOH), которая иногда называется поколением 3. Поколение 3 — это физическое поколение, которое логически собирается как часть поколения 2.

Большинство объектов уничтожается при сборке мусора для поколения 0 и не доживает до следующего поколения.

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

Когда сборщик мусора выполняет сборку для поколения 0, память уплотняется для достижимых объектов и они продвигаются в поколение 1. Так как объекты, оставшиеся после сборки, обычно склонны к долгой жизни, имеет смысл продвинуть их в поколение более высокого уровня. Сборщику мусора необязательно выполнять повторную проверку объектов поколений 1 и 2 при каждой сборке мусора поколения 0.

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

Объекты поколения 2, которые сохраняют коллекцию, остаются в поколении 2, пока они не будут недоступны в будущей коллекции.

Объекты в куче больших объектов (иногда называемой поколением 3) также собираются в поколении 2.

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

Выживание и переходы

Объекты, которые не были восстановлены в сборке мусора, известны как выжившие и повышены до следующего поколения:

Объекты, оставшиеся после сборки мусора поколения 0, подвигаются в поколение 1.
Объекты, оставшиеся после сборки мусора поколения 1, подвигаются в поколение 2.
Объекты, оставшиеся после сборки мусора поколения 2, остаются в поколении 2.

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

Эфемерные поколения и сегменты

Так как объекты в поколениях 0 и 1 являются короткоживущими, эти поколения называются эфемерными поколениями.

Эфемерные поколения выделяются в сегменте памяти, который называется эфемерным сегментом. Каждый новый сегмент, полученный сборщиком мусора, становится новым эфемерным сегментом и содержит объекты, пережившие сборку мусора для поколения 0. Старый эфемерный сегмент становится новым сегментом поколения 2.

Размер эфемерного сегмента зависит от того, является ли система 32-разрядной или 64-разрядной, а также от типа выполняемого сборщика мусора (рабочая станция или серверная сборка мусора). В следующей таблице показаны размеры по умолчанию для эфемерного сегмента:

Сборка мусора рабочей станции и сервера	32-разрядное	64-разрядное
Сборщик мусора рабочей станции	16 МБ	256 МБ
Сборщик мусора сервера	64 МБ	4 ГБ
GC сервера с > 4 логическими ЦП	32 МБ	2 ГБ
GC сервера с > 8 логическими ЦП	16 МБ	1 ГБ

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

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

Процесс сборки мусора

Сборка мусора состоит из следующих этапов:

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

Так как сборки поколения 2 могут занимать несколько сегментов, объекты, перешедшие в поколение 2, могут быть перемещены в более старый сегмент. Как поколение 1, так и 2 выживших можно переместить в другой сегмент, потому что они повышены до поколения 2.

Обычно большая куча объектов (LOH) не сжимается, так как копирование больших объектов накладывает штраф за производительность. Однако в .NET Core и в .NET Framework 4.5.1 и более поздних версиях можно использовать свойство GCSettings.LargeObjectHeapCompactionMode для сжатия большой кучи объектов по требованию. Кроме того, куча больших объектов автоматически сжимается при установке жесткого ограничения с помощью одного из следующих параметров:
- Предельный объем памяти для контейнера.
- Параметры конфигурации среды выполнения GCHeapHardLimit или GCHeapHardLimitPercent .

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

Корни стека: переменные стека, предоставляемые JIT-компилятором и обходчиком стека. JIT-оптимизация позволяет уменьшить или увеличить области кода, в которых переменные стека сообщаются сборщику мусора.
Дескриптор сборки мусора: обрабатывает управляемые объекты, которые можно выделить с помощью пользовательского кода или среды CLR.
Статические данные: статические объекты в доменах приложений, которые могут ссылаться на другие объекты. Каждый домен приложения следит за своими статическими объектами.

Перед запуском сборки мусора все управляемые потоки, кроме потока, запустившего сборку мусора, приостанавливаются.

На следующем рисунке показан поток, который активирует сборку мусора и приводит к приостановке других потоков:

Снимок экрана: запуск потока сборки мусора.

Неуправляемые ресурсы

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

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

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

См. сведения об очистке неуправляемых ресурсов.