Что такое сборщик мусора c
Перейти к содержимому

Что такое сборщик мусора c

  • автор:

Сборка мусора, управление памятью и указатели

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

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

Test(); void Test() < Person tom = new Person("Tom"); Console.WriteLine(tom.Name); >record class Person(string Name);

В методе Test создается объект Person. С помощью оператора new в куче для хранения объекта CLR выделяет участок памяти. А в стек добавляет адрес на этот участок памяти. В неявно определенном методе Main мы вызываем метод Test. И после того, как Test отработает, место в стеке очищается, а сборщик мусора очищает ранее выделенный под хранение объекта Person участок памяти.

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

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

Так же надо отметить, что для крупных объектов существует своя куча — Large Object Heap . В эту кучу помещаются объекты, размер которых больше 85 000 байт. Особенность этой кучи состоит в том, что при сборке мусора сжатие памяти не проводится по причине больших издержек, связанных с размером объектов.

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

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

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

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

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

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

Класс System.GC

Функционал сборщика мусора в библиотеке классов .NET представляет класс System.GC . Через статические методы данный класс позволяет обращаться к сборщику мусора. Как правило, надобность в применении этого класса отсутствует. Наиболее распространенным случаем его использования является сборка мусора при работе с неуправляемыми ресурсами, при интенсивном выделении больших объемов памяти, при которых необходимо такое же быстрое их освобождение.

Рассмотрим некоторые методы и свойства класса System.GC:

  • Метод AddMemoryPressure информирует среду CLR о выделении большого объема неуправляемой памяти, которую надо учесть при планировании сборки мусора. В связке с этим методом используется метод RemoveMemoryPressure , который указывает CLR, что ранее выделенная память освобождена, и ее не надо учитывать при сборке мусора.
  • Метод Collect приводит в действие механизм сборки мусора. Перегруженные версии метода позволяют указать поколение объектов, вплоть до которого надо произвести сборку мусора
  • Метод GetGeneration(Object) позволяет определить номер поколения, к которому относится переданый в качестве параметра объект
  • Метод GetTotalMemory возвращает объем памяти в байтах, которое занято в управляемой куче
  • Метод WaitForPendingFinalizers приостанавливает работу текущего потока до освобождения всех объектов, для которых производится сборка мусора

Работать с методами System.GC несложно:

// . long totalMemory = GC.GetTotalMemory(false); GC.Collect(); GC.WaitForPendingFinalizers(); //.

С помощью перегруженных версий метода GC.Collect можно выполнить более точную настройку сборки мусора. Так, его перегруженная версия принимает в качестве параметра число — номер поколения, вплоть до которого надо выполнить очистку. Например, GC.Collect(0) — удаляются только объекты поколения 0.

Еще одна перегруженная версия принимает еще и второй параметр — перечисление GCCollectionMode . Это перечисление может принимать три значения:

  • Default : значение по умолчанию для данного перечисления (Forced)
  • Forced : вызывает немедленное выполнение сборки мусора
  • Optimized : позволяет сборщику мусора определить, является ли текущий момент оптимальным для сборки мусора

Например, немедленная сборка мусора вплоть до первого поколения объектов: GC.Collect(1, GCCollectionMode.Forced);

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

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

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

Преимущества

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

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

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

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

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

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

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

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

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

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

Механизм оптимизации сборщика мусора определяет наилучшее время для выполнения сбора, основываясь на произведенных выделениях памяти. Когда сборщик мусора выполняет очистку, он освобождает память, выделенную для объектов, которые больше не используются приложением. Он определяет, какие объекты больше не используются, анализируя корни приложения. Корни приложения содержат статические поля, локальные переменные в стеке потока, регистры процессора, дескрипторы сборки мусора и очередь завершения. Каждый корень либо ссылается на объект, находящийся в управляемой куче, либо имеет значение 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 Гбайт
Серверная сборка мусора с 4 логическими > ЦП 32 МБ 2 ГБ
Сборка мусора сервера с 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().

    См. также

    • Сборка мусора рабочей станции и сборка мусора сервера
    • Фоновая сборка мусора
    • Параметры конфигурации для сборки мусора
    • Сборка мусора

    Совместная работа с нами на GitHub

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

    Что такое сборщик мусора c

    В программировании сборка мусора (устоявшийся термин, с точки зрения русского языка правильнее «сбор мусора», англ. garbage collection, GC) — одна из форм автоматического управления памятью. Специальный код, называемый сборщиком мусора (garbage collector), периодически освобождает память, удаляя объекты, которые уже не будут востребованы приложением — то есть производит сборку мусора.

    Цитата из Википедии

    Посмотрите на следующий код:

    Много раз мы анализировали работу подобного кода по шагам:

    1. Создаётся переменная с именем x (ячейка фиксированной длины в памяти)
    2. Где-то в памяти создаётся объект
    3. Ссылка на созданный объект помещается в переменную x

    Все ясно, правда?

    А теперь, следом за первой строкой кода запишем вторую:

    Здесь тоже все понятно: число 1 записывается в переменную x (в ту ячейку памяти фиксированной длины, которая отведена под x ).

    А что случилось со ссылкой на объект? Понятно, что. Она пропала, затерлась единицей. А что случилось с самим объектом?

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

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

    Конечно, мусор надо убирать. За чистотой в доме следит сборщик мусора — составная часть интерпретатора JavaScript.

    Область памяти Ссылки

    У сборщика мусора есть «журнал» учета памяти.

    Область памяти Ссылки
    x

    Вид журнала (условно) после выполнения первой строки:

    Область памяти Ссылки
    нет ссылок

    Вид журнала (условно) после выполнения второй строки:

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

    А теперь посмотрите на следующий код:

    ; var y = x; x = 1; 

    Есть работа для сборщика мусора? Нет, он отдыхает. В самом деле, посмотрим, как заполняется журнал учета памяти.

    После первой команды:

    Область памяти Ссылки
    x

    Сборка мусора

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

    Заголовок Описание
    Основы сборки мусора Описание работы сборки мусора, выделения объектов в управляемой куче и других базовых понятий.
    Сборка мусора рабочей станции и сборка мусора сервера Описывает различия между сборкой мусора рабочей станции для клиентских приложений и сборкой мусора сервера для серверных приложений.
    Фоновая сборка мусора Описывает фоновую сборку мусора, которая представляет собой сборку объектов поколения 0 и 1 во время сборки объектов поколения 2.
    Куча больших объектов Описывает кучу больших объектов (LOH) и то, как для них выполняется сборка мусора.
    Сборка мусора и производительность Проверки производительности, которые можно использовать для диагностики проблем со сборкой мусора и производительностью.
    Индуцированные коллекции Описание выполнения сборки мусора.
    Режимы задержки Описание режимов, которые определяют степень вмешательства сборщика мусора.
    Оптимизация совместного размещения веб-сайтов Способы оптимизации сборки мусора на серверах, совместно используемыми небольшими веб-узлами.
    Уведомления о сборке мусора Определение необходимости полной сборки мусора и времени завершения этой операции.
    Отслеживание ресурсов домена приложения Способы наблюдения за использованием ЦП и памяти доменом приложения.
    Слабые ссылки Описание функциональных возможностей, которые позволяют сборщику мусора обрабатывать объект, разрешая при этом приложению получать доступ к этому объекту.

    Справочник

    • System.GC
    • System.GCCollectionMode
    • System.GCNotificationStatus
    • System.Runtime.GCLatencyMode
    • System.Runtime.GCSettings
    • GCSettings.LargeObjectHeapCompactionMode
    • Object.Finalize
    • System.IDisposable

    См. также

    Обратная связь

    Были ли сведения на этой странице полезными?

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *