GC Класс

Определение

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

public ref class GC abstract sealed
public ref class GC sealed
public static class GC
public sealed class GC
type GC = class
Public Class GC
Public NotInheritable Class GC
Наследование
GC

Примеры

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

using namespace System;
const long maxGarbage = 1000;
ref class MyGCCollectClass
{
public:
   void MakeSomeGarbage()
   {
      Version^ vt;
      for ( int i = 0; i < maxGarbage; i++ )
      {
         
         // Create objects and release them to fill up memory
         // with unused objects.
         vt = gcnew Version;

      }
   }

};

int main()
{
   MyGCCollectClass^ myGCCol = gcnew MyGCCollectClass;
   
   // Determine the maximum number of generations the system
   // garbage collector currently supports.
   Console::WriteLine( "The highest generation is {0}", GC::MaxGeneration );
   myGCCol->MakeSomeGarbage();
   
   // Determine which generation myGCCol object is stored in.
   Console::WriteLine( "Generation: {0}", GC::GetGeneration( myGCCol ) );
   
   // Determine the best available approximation of the number
   // of bytes currently allocated in managed memory.
   Console::WriteLine( "Total Memory: {0}", GC::GetTotalMemory( false ) );
   
   // Perform a collection of generation 0 only.
   GC::Collect( 0 );
   
   // Determine which generation myGCCol object is stored in.
   Console::WriteLine( "Generation: {0}", GC::GetGeneration( myGCCol ) );
   Console::WriteLine( "Total Memory: {0}", GC::GetTotalMemory( false ) );
   
   // Perform a collection of all generations up to and including 2.
   GC::Collect( 2 );
   
   // Determine which generation myGCCol object is stored in.
   Console::WriteLine( "Generation: {0}", GC::GetGeneration( myGCCol ) );
   Console::WriteLine( "Total Memory: {0}", GC::GetTotalMemory( false ) );
}
using System;

namespace GCCollectIntExample
{
    class MyGCCollectClass
    {
        private const long maxGarbage = 1000;

        static void Main()
        {
            MyGCCollectClass myGCCol = new MyGCCollectClass();

            // Determine the maximum number of generations the system
        // garbage collector currently supports.
            Console.WriteLine("The highest generation is {0}", GC.MaxGeneration);

            myGCCol.MakeSomeGarbage();

            // Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol));

            // Determine the best available approximation of the number
        // of bytes currently allocated in managed memory.
            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(false));

            // Perform a collection of generation 0 only.
            GC.Collect(0);

            // Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol));

            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(false));

            // Perform a collection of all generations up to and including 2.
            GC.Collect(2);

            // Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol));
            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(false));
            Console.Read();
        }

        void MakeSomeGarbage()
        {
            Version vt;

            for(int i = 0; i < maxGarbage; i++)
            {
                // Create objects and release them to fill up memory
        // with unused objects.
                vt = new Version();
            }
        }
    }
}
Namespace GCCollectInt_Example
    Class MyGCCollectClass
        Private maxGarbage As Long = 10000

        Public Shared Sub Main()
            Dim myGCCol As New MyGCCollectClass

            'Determine the maximum number of generations the system
            'garbage collector currently supports.
            Console.WriteLine("The highest generation is {0}", GC.MaxGeneration)

            myGCCol.MakeSomeGarbage()

            'Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol))

            'Determine the best available approximation of the number 
            'of bytes currently allocated in managed memory.
            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(False))

            'Perform a collection of generation 0 only.
            GC.Collect(0)

            'Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol))

            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(False))

            'Perform a collection of all generations up to and including 2.
            GC.Collect(2)

            'Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol))
            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(False))
            Console.Read()

        End Sub


        Sub MakeSomeGarbage()
            Dim vt As Version

            Dim i As Integer
            For i = 0 To maxGarbage - 1
                'Create objects and release them to fill up memory
                'with unused objects.
                vt = New Version
            Next i
        End Sub
    End Class
End Namespace

Комментарии

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

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

Сборка мусора состоит из следующих шагов.

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

  2. Сборщик мусора пытается завершить объекты, на которые нет ссылок.

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

Этот раздел включает следующие подразделы:

Сборщик мусора и неуправляемые ресурсы
Устаревание и поколения объектов
Запрещена сборка мусора

Сборщик мусора и неуправляемые ресурсы

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

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

В большинстве случаев методы завершения реализуются путем переопределения Object.Finalize метода, однако типы, написанные на C# или C++, реализуют деструкторы, которые компилятор преобразует в Переопределение Object.Finalize . В большинстве случаев, если у объекта есть метод завершения, сборщик мусора вызывает его перед освобождением объекта. Однако сборщик мусора не требуется вызывать методы завершения во всех ситуациях. Например, SuppressFinalize метод явно предотвращает вызов метода завершения объекта. Кроме того, сборщик мусора не обязан использовать конкретный поток для завершения объектов или гарантировать, что методы завершения вызываются для объектов, ссылающихся друг на друга, но в других случаях доступны для сборки мусора.

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

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

Устаревание и поколения объектов

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

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

Запрещена сборка мусора

начиная с платформа .NET Framework 4,6, сборщик мусора поддерживает режим задержки без области GC, который можно использовать во время выполнения критических путей, в которых сбор мусора может негативно сказаться на производительности приложения. Режим задержки без области GC требует указать объем памяти, который может быть выделен без помех от сборщика мусора. Если среда выполнения может выделить эту память, среда выполнения не будет выполнять сборку мусора во время выполнения кода критического пути.

Вы определяете начало критического пути к области без GC, вызывая одну из перегрузок TryStartNoGCRegion . Чтобы указать конец критического пути, вызовите EndNoGCRegion метод.

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

Свойства

MaxGeneration

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

Методы

AddMemoryPressure(Int64)

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

AllocateArray<T>(Int32, Boolean)

Выделяет массив.

AllocateUninitializedArray<T>(Int32, Boolean)

Выделяет массив при пропуске нулевой инициализации, если это возможно.

CancelFullGCNotification()

Отменяет регистрацию уведомления о сборке мусора.

Collect()

Принудительно запускает немедленную сборку мусора для всех поколений.

Collect(Int32)

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

Collect(Int32, GCCollectionMode)

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

Collect(Int32, GCCollectionMode, Boolean)

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

Collect(Int32, GCCollectionMode, Boolean, Boolean)

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

CollectionCount(Int32)

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

EndNoGCRegion()

Завершает режим задержки без области сборки мусора.

GetAllocatedBytesForCurrentThread()

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

GetGCMemoryInfo()

Возвращает сведения о памяти при сборке мусора.

GetGCMemoryInfo(GCKind)

Возвращает сведения о памяти при сборке мусора.

GetGeneration(Object)

Возвращает номер текущего поколения указанного объекта.

GetGeneration(WeakReference)

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

GetTotalAllocatedBytes(Boolean)

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

GetTotalMemory(Boolean)

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

KeepAlive(Object)

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

RegisterForFullGCNotification(Int32, Int32)

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

RemoveMemoryPressure(Int64)

Информирует среду выполнения о том, что неуправляемая память освобождена и ее более не требуется учитывать при планировании сборки мусора.

ReRegisterForFinalize(Object)

Требует, чтобы система вызвала метод завершения для указанного объекта, для которого ранее был вызван метод SuppressFinalize(Object).

SuppressFinalize(Object)

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

TryStartNoGCRegion(Int64)

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

TryStartNoGCRegion(Int64, Boolean)

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

TryStartNoGCRegion(Int64, Int64)

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

TryStartNoGCRegion(Int64, Int64, Boolean)

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

WaitForFullGCApproach()

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

WaitForFullGCApproach(Int32)

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

WaitForFullGCComplete()

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

WaitForFullGCComplete(Int32)

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

WaitForPendingFinalizers()

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

Применяется к

См. также раздел