GC Classe

Definição

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

Herança

Object

GC

Exemplos

O exemplo a seguir usa vários métodos GC para obter informações de geração e memória sobre um bloco de objetos não utilizados e imprimi-lo no console. Os objetos não utilizados são então coletados e os totais de memória resultantes são exibidos.

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

Comentários

A GC classe controla o coletor de lixo. O coletor de lixo é um componente de common language runtime que controla a alocação e a liberação da memória gerenciada. Os métodos nessa classe influenciam quando a coleta de lixo é executada em um objeto e quando os recursos alocados por um objeto são liberados. As propriedades nesta classe fornecem informações sobre a quantidade total de memória disponível no sistema e a categoria de idade, ou geração, de memória alocada a um objeto.

O coletor de lixo rastreia e recupera objetos alocados na memória gerenciada. Periodicamente, o coletor de lixo executa a coleta de lixo para recuperar a memória alocada a objetos para os quais não há referências válidas. A coleta de lixo ocorre automaticamente quando uma solicitação de memória não pode ser atendida usando a memória gratuita disponível. Como alternativa, um aplicativo pode forçar a coleta de lixo usando o Collect método.

A coleta de lixo consiste nas seguintes etapas:

1. O coletor de lixo procura objetos gerenciados referenciados no código gerenciado.
2. O coletor de lixo tenta finalizar objetos que não são referenciados.
3. O coletor de lixo libera objetos que não são referenciados e recupera sua memória.

Recursos não gerenciados

Durante uma coleta, o coletor de lixo não liberará um objeto se encontrar uma ou mais referências ao objeto no código gerenciado. No entanto, o coletor de lixo não reconhece referências a um objeto provenientes de código não gerenciado e pode liberar objetos que estão sendo usados exclusivamente nesse código, a menos que se impeça explicitamente que isso aconteça. O KeepAlive método fornece um mecanismo que impede o coletor de lixo de coletar objetos que ainda estão em uso no código não gerenciado.

Além das alocações de memória gerenciadas, as implementações do coletor de lixo não mantêm informações sobre recursos mantidos por um objeto, como identificadores de arquivo ou conexões de banco de dados. Quando um tipo usa recursos não gerenciados que devem ser liberados antes que as instâncias do tipo sejam recuperadas, o tipo pode implementar um finalizador.

Na maioria dos casos, os finalizadores são implementados substituindo o método Object.Finalize no entanto, os tipos escritos em C# ou C++ implementam destruidores, que os compiladores transformam em uma substituição de Object.Finalize. Na maioria dos casos, se um objeto tiver um finalizador, o coletor de lixo o chamará antes de liberar o objeto. No entanto, o coletor de lixo não é obrigado a chamar finalizadores em todas as situações; por exemplo, o método SuppressFinalize impede explicitamente que o finalizador de um objeto seja chamado. Além disso, o coletor de lixo não é obrigado a usar uma thread específica para finalizar objetos ou garantir a ordem em que os finalizadores são chamados para objetos que fazem referência uns aos outros, mas que estão disponíveis para a coleta de lixo.

Em cenários em que os recursos devem ser liberados em um momento específico, as classes podem implementar a IDisposable interface, que contém o IDisposable.Dispose método que executa tarefas de gerenciamento de recursos e limpeza. As classes que implementam Dispose devem especificar, como parte de seu contrato de classe, se e quando os consumidores da classe devem chamar o método para limpar o objeto. O coletor de lixo não chama, por padrão, o Dispose método; no entanto, as Dispose implementações do método podem chamar métodos na GC classe para personalizar o comportamento de finalização do coletor de lixo.

Para obter mais informações sobre a finalização do objeto e o padrão de descarte, consulte Limpeza de recursos não gerenciados.

Envelhecimento e gerações de objetos

O coletor de lixo no common language runtime dá suporte ao envelhecimento do objeto usando gerações. Uma geração é uma unidade de medida da idade relativa dos objetos na memória. O número de geração, ou idade, de um objeto indica a geração à qual um objeto pertence. Os objetos criados mais recentemente fazem parte de gerações mais recentes e têm números de geração mais baixos do que os objetos criados anteriormente no ciclo de vida do aplicativo. Os objetos na geração mais recente estão na geração 0. Essa implementação do coletor de lixo dá suporte a três gerações de objetos, as gerações 0, 1 e 2. Você pode recuperar o valor da MaxGeneration propriedade para determinar o número máximo de geração compatível com o sistema.

O envelhecimento de objetos permite que os aplicativos direcionem a coleta de lixo em um conjunto específico de gerações, em vez de exigir que o coletor de lixo avalie todas as gerações. As sobrecargas do método Collect que incluem um parâmetro generation permitem que você especifique a geração mais antiga a ser coletada pelo coletor de lixo.

Não permitir coleta de lixo

O coletor de lixo oferece suporte a um modo de latência de região sem GC que pode ser usado durante a execução de caminhos críticos nos quais a coleta de lixo pode afetar negativamente o desempenho de um aplicativo. O modo de latência de região sem GC exige que você especifique uma quantidade de memória que possa ser alocada sem interferência do coletor de lixo. Se o runtime puder alocar essa memória, o runtime não executará uma coleta de lixo enquanto o código no caminho crítico estiver em execução.

Você define o início do caminho crítico da região sem GC chamando uma das sobrecargas do TryStartNoGCRegion. Especifique o final de seu caminho crítico chamando o EndNoGCRegion método.

Você não pode aninhar chamadas para o método TryStartNoGCRegion e só deve chamar o método EndNoGCRegion se o runtime estiver atualmente no modo de latência de região sem GC. Em outras palavras, você não deve chamar TryStartNoGCRegion várias vezes (após a primeira chamada de método, as chamadas subsequentes não serão bem-sucedidas) e você não deve esperar que as chamadas EndNoGCRegion sejam bem-sucedidas apenas porque a primeira chamada TryStartNoGCRegion foi bem-sucedida.

Confira também

• GCSettings
• Coleta de lixo
• Fundamentos da coleta de lixo