GC Třída

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

GC.cs

Řídí systém uvolňování paměti, službu, která automaticky uvolní nevyužitou paměť.

public ref class GC abstract sealed

public static class GC

type GC = class

Public Class GC

Dědičnost

Object

GC

Příklady

Následující příklad používá několik metod GC získat generování a paměť informace o bloku nepoužívaných objektů a vytisknout je do konzoly. Následně se shromažďují nepoužívané objekty a zobrazí se výsledné součty paměti.

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

Poznámky

Třída GC řídí uvolňovač paměti. Sběrač paměti je komponenta Common Language Runtime (CLR), která řídí přidělování a uvolňování spravované paměti. Metody v této třídě ovlivňují, kdy se provádí uvolňování paměti u objektu a kdy se uvolňují prostředky přidělené objektem. Vlastnosti v této třídě poskytují informace o celkovém množství paměti dostupné v systému a věkové kategorii nebo generování paměti přidělené objektu.

Systém uvolňování paměti sleduje a recykluje objekty přidělené ve spravované paměti. Garbage collector pravidelně vykonává čištění paměti, aby uvolnil paměť přidělenou objektům, pro které neexistují žádné platné odkazy. Uvolňování paměti probíhá automaticky, když požadavek na paměť nelze splnit pomocí dostupné volné paměti. Případně může aplikace vynutit uvolňování paměti pomocí této metody Collect.

Garbage collection se skládá z následujících kroků:

1. Systém garbage collector vyhledá spravované objekty, na které odkazuje kód.
2. Správce paměti se pokouší finalizovat objekty, na které se neodkazuje.
3. Garbage collector uvolňuje objekty, na které se neodkazuje, a obnovuje jejich paměť.

Nespravované zdroje

Během provádění kolekce nezpracovávač paměti neuvolní objekt, pokud najde jeden nebo více odkazů na tento objekt ve spravovaném kódu. Systém uvolňování paměti však nerozpozná odkazy na objekt z nespravovaného kódu a může uvolnit objekty, které se používají výhradně v nespravovaném kódu, pokud tomu není explicitně zabráněno. Tato KeepAlive metoda poskytuje mechanismus, který zabrání garbage collectoru ve shromažďování objektů, které se stále používají v nespravovaném kódu.

Kromě přidělování spravované paměti neudržují implementace správy paměti informace o prostředcích uchovávaných objektem, jako jsou popisovače souborů nebo připojení k databázi. Pokud typ používá nespravované prostředky, které musí být uvolněny před tím, než jsou instance typu zrušeny, může typ implementovat finalizátor.

Ve většině případů jsou finalizátory implementovány přepsáním Object.Finalize metody; typy napsané v jazyce C# nebo C++ implementují destruktory, které kompilátory změní na přepsání Object.Finalize. Ve většině případů, pokud má objekt finalizátor, garbage collector ho zavolá před uvolněním objektu. Nicméně systém uvolňování paměti nemusí volat finalizátory ve všech situacích; metoda například SuppressFinalize explicitně zabraňuje zavolání finalizátoru objektu. Také garbage collector není povinen použít konkrétní vlákno k dokončení objektů ani zaručit pořadí volání finalizérů u objektů, které se vzájemně odkazují, ale jsou jinak k dispozici pro uvolnění paměti.

Ve scénářích, kdy je nutné uvolnit prostředky v určitou dobu, mohou třídy implementovat IDisposable rozhraní, které obsahuje metodu IDisposable.Dispose pro správu a úklid prostředků. Třídy, které implementují Dispose, musí ve svém kontraktu určit, zda a kdy uživatelé třídy volají metodu pro vyčištění objektu. Sběrač paměti ve výchozím nastavení metodu Dispose nevolá; implementace metody Dispose však mohou volat metody ve třídě GC, aby přizpůsobily chování finalizace sběrače paměti.

Další informace o finalizaci objektů a vzoru dispose naleznete v tématu Čištění nespravovaných prostředků.

Stárnutí objektů a generace

Garbage collector v CLR (Common Language Runtime) podporuje stárnutí objektů pomocí generací. Generování je měrná jednotka relativního stáří objektů v paměti. Číslo generování nebo stáří objektu označuje generaci, do které objekt patří. Objekty vytvořené v poslední době jsou součástí novějších generací a mají nižší čísla generace než objekty vytvořené dříve v životním cyklu aplikace. Objekty v nejnovější generaci jsou v generaci 0. Tato implementace sběrače paměti podporuje tři generace objektů, generace 0, 1 a 2. Můžete načíst hodnotu MaxGeneration vlastnosti a určit maximální počet generování podporovaný systémem.

Stárnutí objektů umožňuje aplikacím zaměřit uvolňování paměti na konkrétní sadu generací, aniž by bylo nutné, aby garbage collector vyhodnocoval všechny generace. Přetížení metody Collect, která obsahují parametr generation, umožňují určit nejstarší generaci, která má být uvolněna z paměti.

Zakázání správy paměti

Sběrač odpadu podporuje režim latence bez oblasti GC, který lze využít během provádění kritických úseků, kde sběr odpadu může nepříznivě ovlivnit výkon aplikace. Režim latence oblasti bez uvolňování paměti vyžaduje, abyste zadali množství paměti, které lze přidělit bez rušení správce paměti. Pokud modul runtime může přidělit tuto paměť, modul runtime neprovádí uvolňování paměti, zatímco se spouští kód v kritické cestě.

Začátek kritické dráhy oblasti bez GC definujete voláním jednoho z přetížení TryStartNoGCRegion. Konec kritické cesty zadáte voláním EndNoGCRegion metody.

Volání metody TryStartNoGCRegion nelze vnořit a metodu EndNoGCRegion byste měli volat pouze v případě, že modul runtime není aktuálně v režimu latence oblasti GC. Jinými slovy, neměli byste volat TryStartNoGCRegion vícekrát (po prvním volání metody, následná volání nebudou úspěšná) a neměli byste očekávat, že volání budou EndNoGCRegion úspěšná pouze proto, že první volání bylo TryStartNoGCRegion úspěšné.

Vlastnosti

Name	Description
MaxGeneration	Získá maximální počet generací, které systém aktuálně podporuje.

Metody

Name	Description
AddMemoryPressure(Int64)	Informuje modul runtime o velkém přidělení nespravované paměti, které je třeba vzít v úvahu při plánování uvolňování paměti.
AllocateArray<T>(Int32, Boolean)	Přidělí pole.
AllocateUninitializedArray<T>(Int32, Boolean)	Pokud je to možné, přidělí pole při vynechání inicializace nuly.
CancelFullGCNotification()	Zruší registraci oznámení o uvolňování paměti.
Collect()	Vynutí okamžité uvolňování paměti všech generací.
Collect(Int32, GCCollectionMode, Boolean, Boolean)	Vynutí uvolňování paměti z generace 0 do zadané generace v době určené GCCollectionMode hodnotou s hodnotami, které určují, zda má kolekce blokovat a komprimovat.
Collect(Int32, GCCollectionMode, Boolean)	Vynutí uvolňování paměti z generace 0 do zadané generace v okamžiku určeném GCCollectionMode hodnotou s hodnotou určující, zda má být kolekce blokovaná.
Collect(Int32, GCCollectionMode)	Vynutí uvolňování paměti z generace 0 do zadané generace v okamžiku určeném GCCollectionMode hodnotou.
Collect(Int32)	Vynutí okamžité uvolňování paměti z generace 0 prostřednictvím zadané generace.
CollectionCount(Int32)	Vrátí počet výskytů uvolňování paměti pro zadané generování objektů.
EndNoGCRegion()	Ukončí režim latence oblasti GC.
GetAllocatedBytesForCurrentThread()	Získá celkový počet bajtů přidělených aktuálnímu vláknu od začátku jeho životnosti.
GetConfigurationVariables()	Získá konfigurace používané uvolňováním paměti.
GetGCMemoryInfo()	Získá informace o paměti uvolňování paměti.
GetGCMemoryInfo(GCKind)	Získá informace o paměti uvolňování paměti.
GetGeneration(Object)	Vrátí číslo aktuální generace zadaného objektu.
GetGeneration(WeakReference)	Vrátí číslo aktuální generace cíle zadaného slabého odkazu.
GetTotalAllocatedBytes(Boolean)	Získá počet bajtů přidělených v průběhu životnosti procesu. Vrácená hodnota nezahrnuje žádné nativní přidělení.
GetTotalMemory(Boolean)	Načte velikost haldy s výjimkou fragmentace. Pokud je například celková velikost haldy GC 100 mb a fragmentace, tj. mezera zabírající volné objekty, zabírá 40 mb, toto rozhraní API by hlásilo 60 mb. Parametr označuje, zda tato metoda může počkat krátký interval před vrácením, aby systém mohl shromažďovat uvolňování paměti a finalizovat objekty.
GetTotalPauseDuration()	Získá celkovou dobu pozastavení v GC od začátku procesu.
KeepAlive(Object)	Odkazuje na zadaný objekt, díky kterému je způsobilý pro uvolňování paměti od začátku aktuální rutiny do bodu, kde je tato metoda volána.
RefreshMemoryLimit()	Dá pokyn systému uvolňování paměti, aby se překonfiguroval tak, že zjistí různá omezení paměti v systému.
RegisterForFullGCNotification(Int32, Int32)	Určuje, že má být vyvolána oznámení o uvolňování paměti, když podmínky upřednostňují úplné uvolňování paměti a po dokončení kolekce.
RegisterNoGCRegionCallback(Int64, Action)	Zaregistruje zpětné volání, které se má vyvolat, když je v žádné oblasti GC přiděleno určité množství paměti.
RemoveMemoryPressure(Int64)	Informuje modul runtime, že byla vydána nespravovaná paměť a při plánování uvolňování paměti už není nutné brát v úvahu.
ReRegisterForFinalize(Object)	Požaduje, aby systém volal finalizační metodu pro zadaný objekt, pro který SuppressFinalize(Object) byl dříve volána.
SuppressFinalize(Object)	Vyžaduje, aby modul CLR (Common Language Runtime) nevolal finalizátor zadaného objektu.
TryStartNoGCRegion(Int64, Boolean)	Pokusí se zakázat uvolňování paměti během provádění kritické cesty, pokud je k dispozici zadané množství paměti, a určuje, zda uvolňování paměti provádí úplné blokování uvolňování paměti, pokud není zpočátku k dispozici dostatek paměti.
TryStartNoGCRegion(Int64, Int64, Boolean)	Pokusí se zakázat uvolňování paměti během provádění kritické cesty, pokud je pro haldu velkého objektu a haldy malého objektu k dispozici určité množství paměti, a určuje, zda uvolňování paměti provádí úplné blokování uvolňování paměti, pokud není zpočátku k dispozici dostatek paměti.
TryStartNoGCRegion(Int64, Int64)	Pokusí se zakázat uvolňování paměti během provádění kritické cesty, pokud je pro velkou haldu objektu a haldu malého objektu k dispozici zadané množství paměti.
TryStartNoGCRegion(Int64)	Pokusí se zakázat uvolňování paměti během provádění kritické cesty, pokud je k dispozici zadané množství paměti.
WaitForFullGCApproach()	Vrátí stav registrovaného oznámení pro určení, zda je úplné blokování uvolňování paměti modulem CLR (Common Language Runtime).
WaitForFullGCApproach(Int32)	Vrátí stav registrovaného oznámení v zadaném časovém limitu, který určuje, jestli je úplné blokování uvolňování paměti modulem CLR (Common Language Runtime) bezprostředně zablokované.
WaitForFullGCApproach(TimeSpan)	Vrátí stav registrovaného oznámení v zadaném časovém limitu, který určuje, jestli je úplné blokování uvolňování paměti modulem CLR (Common Language Runtime) bezprostředně zablokované.
WaitForFullGCComplete()	Vrátí stav registrovaného oznámení pro určení, jestli se dokončilo úplné blokování uvolňování paměti modulem CLR (Common Language Runtime).
WaitForFullGCComplete(Int32)	Vrátí stav registrovaného oznámení v zadaném časovém limitu pro určení, jestli úplné blokování uvolňování paměti běžným jazykem, které modul runtime dokončil.
WaitForFullGCComplete(TimeSpan)	Vrátí stav registrovaného oznámení o tom, jestli se dokončilo blokování uvolňování paměti. Může čekat na neomezenou dobu na úplnou kolekci.
WaitForPendingFinalizers()	Pozastaví aktuální vlákno, dokud vlákno, které zpracovává frontu finalizačních metod, nevyprázdní tuto frontu.

Viz také

• GCSettings
• Sběr odpadu
• Základy Garbage Collection