GC.Collect 메서드

Source:

GC.CoreCLR.cs

Source:

GC.CoreCLR.cs

Source:

GC.CoreCLR.cs

public:
 static void Collect();

public static void Collect ();

static member Collect : unit -> unit

Public Shared Sub Collect ()

예제

다음 예제에서는 메서드를 사용 하 여 Collect 모든 세대의 메모리에서 컬렉션을 수행 하는 방법을 보여 줍니다. 이 코드는 사용되지 않는 여러 개체를 생성한 다음 메서드를 Collect 호출하여 메모리에서 클린.

using namespace System;

const int maxGarbage = 1000;

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;
   }
}

void main()
{
   // Put some objects in memory.
   MakeSomeGarbage();
   Console::WriteLine("Memory used before collection:       {0:N0}", 
                      GC::GetTotalMemory( false ) );
   
   // Collect all generations of memory.
   GC::Collect();
   Console::WriteLine("Memory used after full collection:   {0:N0}", 
                      GC::GetTotalMemory( true ) );
}
// The output from the example resembles the following:
//       Memory used before collection:       79,392
//       Memory used after full collection:   52,640

using System;

class MyGCCollectClass
{
   private const int maxGarbage = 1000;

   static void Main()
   {
      // Put some objects in memory.
      MyGCCollectClass.MakeSomeGarbage();
      Console.WriteLine("Memory used before collection:       {0:N0}",
                        GC.GetTotalMemory(false));

      // Collect all generations of memory.
      GC.Collect();
      Console.WriteLine("Memory used after full collection:   {0:N0}",
                        GC.GetTotalMemory(true));
   }

   static void MakeSomeGarbage()
   {
      Version vt;

      // Create objects and release them to fill up memory with unused objects.
      for(int i = 0; i < maxGarbage; i++) {
         vt = new Version();
      }
   }
}
// The output from the example resembles the following:
//       Memory used before collection:       79,392
//       Memory used after full collection:   52,640

open System

let maxGarbage = 1000

let makeSomeGarbage () =
    // Create objects and release them to fill up memory with unused objects.
    for _ = 1 to maxGarbage do 
        Version() |> ignore

// Put some objects in memory.
makeSomeGarbage()
printfn $"Memory used before collection:       {GC.GetTotalMemory false:N0}"

// Collect all generations of memory.
GC.Collect()
printfn $"Memory used after full collection:   {GC.GetTotalMemory true:N0}"

// The output from the example resembles the following:
//       Memory used before collection:       79,392
//       Memory used after full collection:   52,640

Class MyGCCollectClass
     Private Const maxGarbage As Integer = 1000

     Shared Sub Main()
         'Put some objects in memory.
         MyGCCollectClass.MakeSomeGarbage()
         Console.WriteLine("Memory used before collection:       {0:N0}", 
                           GC.GetTotalMemory(False))

         'Collect all generations of memory.
         GC.Collect()
         Console.WriteLine("Memory used after full collection:   {0:N0}", 
                           GC.GetTotalMemory(True))
     End Sub

     Shared 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 
     End Sub
 End Class
' The output from the example resembles the following:
'       Memory used before collection:       79,392
'       Memory used after full collection:   52,640

설명

이 메서드를 사용하여 액세스할 수 없는 모든 메모리를 회수합니다. 모든 세대의 차단 가비지 수집을 수행합니다.

메모리에 있는 기간에 관계없이 모든 개체는 컬렉션으로 간주됩니다. 그러나 관리 코드에서 참조되는 개체는 수집되지 않습니다. 이 메서드를 사용하여 시스템에서 사용 가능한 최대 메모리 양을 회수하도록 강제합니다.

.NET Framework 4.5.1부터 다음 예제와 같이 메서드를 호출 Collect 하기 전에 속성을 로 설정 GCSettings.LargeObjectHeapCompactionMode 하여 LOH(큰 개체 힙)를 압축할 GCLargeObjectHeapCompactionMode.CompactOnce 수 있습니다.

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect();

GCSettings.LargeObjectHeapCompactionMode <- GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect()

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect()

추가 정보

• 유도된 컬렉션

Source:

GC.CoreCLR.cs

Source:

GC.CoreCLR.cs

Source:

GC.CoreCLR.cs

public:
 static void Collect(int generation);

public static void Collect (int generation);

static member Collect : int -> unit

Public Shared Sub Collect (generation As Integer)

매개 변수

예외

예제

다음 예제에서는 사용 하는 방법을 보여 줍니다는 메모리의 Collect 개별 계층에서 컬렉션을 수행 하는 방법입니다. 이 코드는 사용되지 않는 여러 개체를 생성한 다음 메서드를 Collect 호출하여 메모리에서 클린.

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();
            }
        }
    }
}

open System

let maxGarbage = 1000

type MyGCCollectClass() =
    member _.MakeSomeGarbage() =
        for _ = 1 to maxGarbage do
            // Create objects and release them to fill up memory with unused objects.
            Version() |> ignore

[<EntryPoint>]
let main _ =
    let myGCCol = MyGCCollectClass()

    // Determine the maximum number of generations the system
    // garbage collector currently supports.
    printfn $"The highest generation is {GC.MaxGeneration}"

    myGCCol.MakeSomeGarbage()

    // Determine which generation myGCCol object is stored in.
    printfn $"Generation: {GC.GetGeneration myGCCol}"

    // Determine the best available approximation of the number
    // of bytes currently allocated in managed memory.
    printfn $"Total Memory: {GC.GetTotalMemory false}"

    // Perform a collection of generation 0 only.
    GC.Collect 0

    // Determine which generation myGCCol object is stored in.
    printfn $"Generation: {GC.GetGeneration myGCCol}"

    printfn $"Total Memory: {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.
    printfn $"Generation: {GC.GetGeneration myGCCol}"
    printfn $"Total Memory: {GC.GetTotalMemory false}"

    0

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

설명

이 메서드를 사용하여 액세스할 수 없는 메모리를 회수합니다. 그러나 이 메서드를 사용하면 지정된 세대에서 액세스할 수 없는 메모리가 모두 회수되는 것은 아닙니다.

개체 에이징이 구현된 경우 가비지 수집기는 지정된 세대보다 높은 세대 번호를 가진 개체를 수집하지 않습니다. 개체 에이징이 구현되지 않은 경우 가비지 수집기는 가비지 수집 중에 모든 개체를 고려합니다.

사용 된 MaxGeneration 매개 변수의 최대 유효한 값을 generation 확인 하려면 속성입니다.

가비지 수집기에서 생성에 관계없이 모든 개체를 고려하도록 하려면 매개 변수를 사용하지 않는 이 메서드의 버전을 사용합니다. 가비지 수집기가 설정에 따라 개체를 GCCollectionMode 회수하도록 하려면 메서드 오버로드를 GC.Collect(Int32, GCCollectionMode) 사용합니다.

추가 정보

• 유도된 컬렉션

Source:

GC.CoreCLR.cs

Source:

GC.CoreCLR.cs

Source:

GC.CoreCLR.cs

public:
 static void Collect(int generation, GCCollectionMode mode);

public static void Collect (int generation, GCCollectionMode mode);

static member Collect : int * GCCollectionMode -> unit

Public Shared Sub Collect (generation As Integer, mode As GCCollectionMode)

매개 변수

예외

예제

다음 예제에서는 설정을 사용하여 2세대 개체에 대한 가비지 수집을 강제합니다 Optimized .

using System;

class Program
{
    static void Main(string[] args)
    {
        GC.Collect(2, GCCollectionMode.Optimized);
    }
}

open System

GC.Collect(2, GCCollectionMode.Optimized)

Class Program

    Public Shared Sub Main()
        GC.Collect(2, GCCollectionMode.Optimized)
    End Sub
End Class

설명

매개 변수를 mode 사용하여 가비지 수집이 즉시 발생해야 하는지 아니면 시간이 개체를 회수하는 데 최적의 경우에만 발생해야 하는지를 지정합니다. 이 메서드를 사용하면 지정된 세대의 모든 액세스할 수 없는 메모리가 회수되는 것을 보장할 수 없습니다.

애플리케이션에서 중요 한 기간 동안 가비지 수집의 실행 시기를 조정 하려면 설정의 LatencyMode 속성입니다.

가비지 수집기는 생성 번호가 매개 변수에 지정된 것보다 높은 개체를 generation 수집하지 않습니다. 사용 된 MaxGeneration 최대 유효한 값을 확인 하려면 속성입니다 generation.

가비지 수집기에서 생성에 관계없이 모든 개체를 고려하도록 하려면 매개 변수를 사용하지 않는 이 메서드의 버전을 사용합니다.

가비지 수집기가 지정된 세대의 개체까지 개체를 회수하도록 하려면 메서드 오버로드를 GC.Collect(Int32) 사용합니다. 최대 생성을 지정하면 모든 개체가 수집됩니다.

추가 정보

• 유도된 컬렉션

Source:

GC.CoreCLR.cs

Source:

GC.CoreCLR.cs

Source:

GC.CoreCLR.cs

public:
 static void Collect(int generation, GCCollectionMode mode, bool blocking);

public static void Collect (int generation, GCCollectionMode mode, bool blocking);

static member Collect : int * GCCollectionMode * bool -> unit

Public Shared Sub Collect (generation As Integer, mode As GCCollectionMode, blocking As Boolean)

매개 변수

예외

설명

다음 표에는 및 blocking 매개 변수의 상호 작용이 mode 요약되어 있습니다.

메서드에 대한 호출이 Collect(Int32, GCCollectionMode, Boolean) 전체 차단 가비지 수집을 수행하는 경우 메서드를 호출하기 전에 속성을 로 설정 GCSettings.LargeObjectHeapCompactionMode 하여 큰 개체 힙을 Collect 압축할 GCLargeObjectHeapCompactionMode.CompactOnce 수도 있습니다.

Source:

GC.CoreCLR.cs

Source:

GC.CoreCLR.cs

Source:

GC.CoreCLR.cs

public:
 static void Collect(int generation, GCCollectionMode mode, bool blocking, bool compacting);

public static void Collect (int generation, GCCollectionMode mode, bool blocking, bool compacting);

static member Collect : int * GCCollectionMode * bool * bool -> unit

Public Shared Sub Collect (generation As Integer, mode As GCCollectionMode, blocking As Boolean, compacting As Boolean)

매개 변수

설명

가 인 false경우 blocking GC는 백그라운드 또는 차단 가비지 수집을 수행할지 여부를 결정합니다. 가 이true면 compacting 가비지 수집을 차단합니다.

가 이true면 compacting 런타임은 SOH(작은 개체 힙)를 압축합니다. 속성이 로 설정GCLargeObjectHeapCompactionMode.CompactOnce되지 않는 한 GCSettings.LargeObjectHeapCompactionMode LOH(큰 개체 힙)는 압축되지 않습니다. 여기에는 전체 차단 가비지 수집뿐만 아니라 모든 차단 가비지 수집이 포함됩니다.

다음 코드 조각과 같이 메서드를 Collect(Int32, GCCollectionMode, Boolean, Boolean) 호출하여 관리되는 힙을 가능한 가장 작은 크기로 줄일 수 있습니다.

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect(2, GCCollectionMode.Forced, true, true);

GCSettings.LargeObjectHeapCompactionMode <- GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect(2, GCCollectionMode.Forced, true, true)

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect(2, GCCollectionMode.Forced, True, True)

인수를 compacting 지정하면 true 압축, 전체 차단 가비지 수집이 보장됩니다. GCSettings.LargeObjectHeapCompactionMode 속성을 로 설정하면 GCLargeObjectHeapCompactionMode.CompactOnce LOH와 SOH가 모두 압축됩니다.