GC.Collect Metoda
Definicja
Ważne
Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.
Wymusza odzyskiwanie pamięci.
Przeciążenia
Collect() |
Wymusza natychmiastowe odzyskiwanie pamięci wszystkich pokoleń. |
Collect(Int32) |
Wymusza natychmiastowe odzyskiwanie pamięci od generacji 0 do określonej generacji. |
Collect(Int32, GCCollectionMode) |
Wymusza odzyskiwanie pamięci z generacji 0 przez określoną generację GCCollectionMode w czasie określonym przez wartość. |
Collect(Int32, GCCollectionMode, Boolean) |
Wymusza odzyskiwanie pamięci z generacji 0 przez określoną generację GCCollectionMode w czasie określonym przez wartość z wartością z wartością określającą, czy kolekcja powinna być blokowana. |
Collect(Int32, GCCollectionMode, Boolean, Boolean) |
Wymusza odzyskiwanie pamięci od generacji 0 do określonej generacji w czasie określonym przez GCCollectionMode wartość z wartościami określającymi, czy kolekcja powinna być blokowana i kompaktowana. |
Collect()
- Źródło:
- GC.CoreCLR.cs
- Źródło:
- GC.CoreCLR.cs
- Źródło:
- GC.CoreCLR.cs
Wymusza natychmiastowe odzyskiwanie pamięci wszystkich pokoleń.
public:
static void Collect();
public static void Collect ();
static member Collect : unit -> unit
Public Shared Sub Collect ()
Przykłady
W poniższym przykładzie pokazano, jak za pomocą Collect metody wykonać kolekcję na wszystkich generacjach pamięci. Kod generuje wiele nieużywanych obiektów, a następnie wywołuje metodę Collect w celu oczyszczenia ich z pamięci.
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
Uwagi
Użyj tej metody, aby spróbować odzyskać całą pamięć, która jest niedostępna. Wykonuje blokowanie odzyskiwania pamięci wszystkich generacji.
Wszystkie obiekty, niezależnie od tego, jak długo znajdują się w pamięci, są brane pod uwagę w przypadku kolekcji; jednak obiekty, do których odwołuje się kod zarządzany, nie są zbierane. Użyj tej metody, aby wymusić na systemie próbę odzyskania maksymalnej ilości dostępnej pamięci.
Począwszy od .NET Framework 4.5.1, można skompaktować duży stertę obiektów (LOH), ustawiając GCSettings.LargeObjectHeapCompactionMode właściwość na GCLargeObjectHeapCompactionMode.CompactOnce przed wywołaniem Collect metody, jak pokazano w poniższym przykładzie.
GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect();
GCSettings.LargeObjectHeapCompactionMode <- GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect()
GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect()
Zobacz też
Dotyczy
Collect(Int32)
- Źródło:
- GC.CoreCLR.cs
- Źródło:
- GC.CoreCLR.cs
- Źródło:
- GC.CoreCLR.cs
Wymusza natychmiastowe odzyskiwanie pamięci od generacji 0 do określonej generacji.
public:
static void Collect(int generation);
public static void Collect (int generation);
static member Collect : int -> unit
Public Shared Sub Collect (generation As Integer)
Parametry
- generation
- Int32
Liczba najstarszych generacji, które mają być wyrzucane śmieci.
Wyjątki
generation
jest nieprawidłowy.
Przykłady
W poniższym przykładzie pokazano, jak za pomocą Collect metody wykonać kolekcję na poszczególnych warstwach pamięci. Kod generuje wiele nieużywanych obiektów, a następnie wywołuje metodę Collect w celu oczyszczenia ich z pamięci.
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
Uwagi
Użyj tej metody, aby spróbować odzyskać pamięć, która jest niedostępna. Jednak użycie tej metody nie gwarantuje odzyskania całej niedostępnej pamięci w określonej generacji.
W przypadku zaimplementowania starzenia się obiektu moduł odśmieceń pamięci nie zbiera obiektów z numerem generacji wyższym niż określona generacja. Jeśli starzenie się obiektu nie zostanie zaimplementowane, moduł odśmieceń pamięci uwzględnia wszystkie obiekty podczas odzyskiwania pamięci.
MaxGeneration Użyj właściwości , aby określić maksymalną prawidłową wartość parametrugeneration
.
Aby moduł odśmiecenia pamięci uwzględniał wszystkie obiekty niezależnie od ich generacji, użyj wersji tej metody, która nie przyjmuje żadnych parametrów. Aby odzyskać obiekty modułu odśmiecanie pamięci na GCCollectionMode podstawie ustawienia, użyj GC.Collect(Int32, GCCollectionMode) przeciążenia metody.
Zobacz też
Dotyczy
Collect(Int32, GCCollectionMode)
- Źródło:
- GC.CoreCLR.cs
- Źródło:
- GC.CoreCLR.cs
- Źródło:
- GC.CoreCLR.cs
Wymusza odzyskiwanie pamięci z generacji 0 przez określoną generację GCCollectionMode w czasie określonym przez wartość.
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)
Parametry
- generation
- Int32
Liczba najstarszych generacji, które mają być wyrzucane śmieci.
- mode
- GCCollectionMode
Wartość wyliczenia określająca, czy odzyskiwanie pamięci jest wymuszone (Default lub Forced) czy zoptymalizowane (Optimized).
Wyjątki
Przykłady
Poniższy przykład wymusza odzyskiwanie pamięci dla obiektów generacji 2 z ustawieniem 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
Uwagi
Użyj parametru , mode
aby określić, czy odzyskiwanie pamięci powinno nastąpić natychmiast, czy tylko wtedy, gdy czas jest optymalny do odzyskania obiektów. Użycie tej metody nie gwarantuje odzyskania całej niedostępnej pamięci w określonej generacji.
Aby dostosować natrętność odzyskiwania pamięci w okresach krytycznych w aplikacji, ustaw LatencyMode właściwość .
Moduł odśmiecający pamięci nie zbiera obiektów o numerze generacji wyższym niż określony przez generation
parametr . Użyj właściwości , MaxGeneration aby określić maksymalną prawidłową wartość .generation
Aby moduł odśmiecenia pamięci uwzględniał wszystkie obiekty niezależnie od ich generacji, użyj wersji tej metody, która nie przyjmuje żadnych parametrów.
Aby odzyskać obiekty modułu odśmiecanie pamięci do określonej generacji obiektów, użyj GC.Collect(Int32) przeciążenia metody. Po określeniu maksymalnej generacji wszystkie obiekty są zbierane.
Zobacz też
Dotyczy
Collect(Int32, GCCollectionMode, Boolean)
- Źródło:
- GC.CoreCLR.cs
- Źródło:
- GC.CoreCLR.cs
- Źródło:
- GC.CoreCLR.cs
Wymusza odzyskiwanie pamięci z generacji 0 przez określoną generację GCCollectionMode w czasie określonym przez wartość z wartością z wartością określającą, czy kolekcja powinna być blokowana.
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)
Parametry
- generation
- Int32
Liczba najstarszych generacji, które mają być wyrzucane śmieci.
- mode
- GCCollectionMode
Wartość wyliczenia określająca, czy odzyskiwanie pamięci jest wymuszone (Default lub Forced) czy zoptymalizowane (Optimized).
- blocking
- Boolean
true
do wykonania blokującego odzyskiwania pamięci; false
aby w miarę możliwości wykonywać odzyskiwanie pamięci w tle.
Wyjątki
Uwagi
W poniższej tabeli przedstawiono podsumowanie interakcji parametrów mode
i blocking
:
mode |
blocking to true |
blocking to false |
---|---|---|
Forced lub Default | Kolekcja blokująca jest wykonywana tak szybko, jak to możliwe. Jeśli kolekcja w tle jest w toku i generation wynosi 0 lub 1, Collect(Int32, GCCollectionMode, Boolean) metoda natychmiast wyzwala blokującą kolekcję i zwraca wartość po zakończeniu kolekcji. Jeśli kolekcja w tle jest w toku i generation ma wartość 2, metoda czeka na zakończenie zbierania w tle, wyzwala blokującą kolekcję generacji 2, a następnie zwraca wartość . |
Kolekcja jest wykonywana tak szybko, jak to możliwe. Metoda Collect(Int32, GCCollectionMode, Boolean) żąda kolekcji w tle, ale nie jest to gwarantowane. W zależności od okoliczności może być nadal wykonywana blokująca kolekcja. Jeśli kolekcja w tle jest już w toku, metoda zwraca natychmiast. |
Optimized | Zbieranie blokujące może być wykonywane w zależności od stanu modułu odśmiecającego pamięci i parametru generation . Moduł odśmiecający elementy bezużyteczne próbuje zapewnić optymalną wydajność. |
Zbieranie może być wykonywane w zależności od stanu modułu odśmiecającego pamięci. Metoda Collect(Int32, GCCollectionMode, Boolean) żąda kolekcji w tle, ale nie jest to gwarantowane. W zależności od okoliczności może być nadal wykonywana blokująca kolekcja. Moduł odśmiecający elementy bezużyteczne próbuje zapewnić optymalną wydajność. Jeśli kolekcja w tle jest już w toku, metoda zwraca natychmiast. |
Jeśli wywołanie Collect(Int32, GCCollectionMode, Boolean) metody wykonuje pełne blokowanie odzyskiwania pamięci, można również skompaktować duży stertę obiektu, ustawiając GCSettings.LargeObjectHeapCompactionMode właściwość na wartość GCLargeObjectHeapCompactionMode.CompactOnce przed wywołaniem Collect metody .
Dotyczy
Collect(Int32, GCCollectionMode, Boolean, Boolean)
- Źródło:
- GC.CoreCLR.cs
- Źródło:
- GC.CoreCLR.cs
- Źródło:
- GC.CoreCLR.cs
Wymusza odzyskiwanie pamięci od generacji 0 do określonej generacji w czasie określonym przez GCCollectionMode wartość z wartościami określającymi, czy kolekcja powinna być blokowana i kompaktowana.
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)
Parametry
- generation
- Int32
Liczba najstarszych generacji, które mają być wyrzucane śmieci.
- mode
- GCCollectionMode
Wartość wyliczenia określająca, czy odzyskiwanie pamięci jest wymuszone (Default lub Forced) czy zoptymalizowane (Optimized).
- blocking
- Boolean
true
do wykonania blokującego odzyskiwania pamięci; false
aby w miarę możliwości wykonywać odzyskiwanie pamięci w tle.
- compacting
- Boolean
true
skompaktować mały stertę obiektu; false
tylko zamiatać.
Uwagi
Jeśli blocking
to false
, GC decyduje, czy wykonać tło, czy blokowanie odzyskiwania pamięci. Jeśli compacting
parametr ma true
wartość , wykonuje blokowanie odzyskiwania pamięci.
Jeśli compacting
parametr ma true
wartość , środowisko uruchomieniowe kompakuje stertę małych obiektów (SOH). Sterta dużych obiektów (LOH) nie jest kompaktowana, chyba że właściwość jest ustawiona GCSettings.LargeObjectHeapCompactionMode na GCLargeObjectHeapCompactionMode.CompactOncewartość . Należy pamiętać, że obejmuje to wszystkie blokowanie odzyskiwania pamięci, a nie tylko pełne blokowanie odzyskiwania pamięci.
Metodę Collect(Int32, GCCollectionMode, Boolean, Boolean) można wywołać, aby zmniejszyć zarządzany stertę do najmniejszego możliwego rozmiaru, jak pokazano na poniższym fragcie kodu.
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)
Określenie true
argumentu compacting
gwarantuje kompaktowanie, pełne blokowanie odzyskiwania pamięci.
GCSettings.LargeObjectHeapCompactionMode Ustawienie właściwości w celu GCLargeObjectHeapCompactionMode.CompactOnce zapewnienia, że zarówno LOH, jak i SOH są kompaktowane.