GC.Collect Método
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Fuerza a que se lleve a cabo la recolección de elementos no utilizados.
Collect() |
Fuerza a que se lleve a cabo una recolección de elementos no utilizados de todas las generaciones. |
Collect(Int32) |
Fuerza a que se lleve a cabo inmediatamente la recolección de elementos no utilizados desde la generación 0 hasta la generación especificada. |
Collect(Int32, GCCollectionMode) |
Fuerza una recolección de elementos no utilizados desde la generación 0 hasta la generación especificada, en el momento especificado por el valor GCCollectionMode. |
Collect(Int32, GCCollectionMode, Boolean) |
Fuerza una recolección de elementos no utilizados de generación 0 en una generación especificada, en un momento especificado por un valor de GCCollectionMode, con un valor que especifica si la recolección debe ser de bloqueo. |
Collect(Int32, GCCollectionMode, Boolean, Boolean) |
Fuerza una recolección de elementos no utilizados de generación 0 en una generación especificada, en un momento especificado por un valor de GCCollectionMode, con valores que especifican si la recolección debe ser de bloqueo y compactante. |
- Source:
- GC.CoreCLR.cs
- Source:
- GC.CoreCLR.cs
- Source:
- GC.CoreCLR.cs
Fuerza a que se lleve a cabo una recolección de elementos no utilizados de todas las generaciones.
public:
static void Collect();
public static void Collect ();
static member Collect : unit -> unit
Public Shared Sub Collect ()
Ejemplos
En el ejemplo siguiente se muestra cómo usar el Collect método para realizar una colección en todas las generaciones de memoria. El código genera una serie de objetos no utilizado y, a continuación, llama al Collect método para limpiarlos de la memoria.
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
Comentarios
Use este método para intentar reclamar toda la memoria inaccesible. Realiza una recolección de elementos no utilizados de bloqueo de todas las generaciones.
Todos los objetos, independientemente de cuánto tiempo hayan estado en memoria, se consideran para la colección; sin embargo, los objetos a los que se hace referencia en el código administrado no se recopilan. Use este método para forzar al sistema a intentar reclamar la cantidad máxima de memoria disponible.
A partir de .NET Framework 4.5.1, puede compactar el montón de objetos grandes (LOH) estableciendo la GCSettings.LargeObjectHeapCompactionMode propiedad GCLargeObjectHeapCompactionMode.CompactOnce en antes de llamar al Collect método , como se muestra en el ejemplo siguiente.
GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect();
GCSettings.LargeObjectHeapCompactionMode <- GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect()
GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce
GC.Collect()
Consulte también
Se aplica a
- Source:
- GC.CoreCLR.cs
- Source:
- GC.CoreCLR.cs
- Source:
- GC.CoreCLR.cs
Fuerza a que se lleve a cabo inmediatamente la recolección de elementos no utilizados desde la generación 0 hasta la generación especificada.
public:
static void Collect(int generation);
public static void Collect (int generation);
static member Collect : int -> unit
Public Shared Sub Collect (generation As Integer)
Parámetros
- generation
- Int32
El número de la generación más antigua de elementos no usados para recolectar.
Excepciones
generation
no es válido.
Ejemplos
En el ejemplo siguiente se muestra cómo usar el Collect método para realizar una colección en capas individuales de memoria. El código genera una serie de objetos no utilizado y, a continuación, llama al Collect método para limpiarlos de la memoria.
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
Comentarios
Use este método para intentar recuperar la memoria inaccesible. Sin embargo, el uso de este método no garantiza que se recupere toda la memoria inaccesible de la generación especificada.
Si se implementa el envejecimiento de objetos, el recolector de elementos no utilizados no recopila objetos con un número de generación mayor que la generación especificada. Si no se implementa el envejecimiento de objetos, el recolector de elementos no utilizados considera todos los objetos durante la recolección de elementos no utilizados.
Use la MaxGeneration propiedad para determinar el valor máximo válido del generation
parámetro.
Para que el recolector de elementos no utilizados tenga en cuenta todos los objetos independientemente de su generación, use la versión de este método que no toma ningún parámetro. Para que el recolector de elementos no utilizados recupere objetos en función de una GCCollectionMode configuración, use la sobrecarga del GC.Collect(Int32, GCCollectionMode) método .
Consulte también
Se aplica a
- Source:
- GC.CoreCLR.cs
- Source:
- GC.CoreCLR.cs
- Source:
- GC.CoreCLR.cs
Fuerza una recolección de elementos no utilizados desde la generación 0 hasta la generación especificada, en el momento especificado por el valor GCCollectionMode.
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)
Parámetros
- generation
- Int32
El número de la generación más antigua de elementos no usados para recolectar.
- mode
- GCCollectionMode
Un valor de enumeración que especifica si se fuerza la recolección de elementos (Default o Forced) o si será optimizada (Optimized).
Excepciones
Ejemplos
En el ejemplo siguiente se fuerza una recolección de elementos no utilizados para los objetos de generación 2 con la Optimized configuración .
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
Comentarios
Use el mode
parámetro para especificar si la recolección de elementos no utilizados debe producirse inmediatamente o solo si el tiempo es óptimo para reclamar objetos. El uso de este método no garantiza que se recupere toda la memoria inaccesible de la generación especificada.
Para ajustar la intrusión de la recolección de elementos no utilizados durante períodos críticos en la aplicación, establezca la LatencyMode propiedad .
El recolector de elementos no utilizados no recopila objetos con un número de generación superior al especificado por el generation
parámetro . Utilice la MaxGeneration propiedad para determinar el valor máximo válido de generation
.
Para que el recolector de elementos no utilizados tenga en cuenta todos los objetos independientemente de su generación, use la versión de este método que no toma ningún parámetro.
Para que el recolector de elementos no utilizados recupere objetos hasta una generación especificada de objetos, use la sobrecarga del GC.Collect(Int32) método . Al especificar la generación máxima, se recopilan todos los objetos.
Consulte también
Se aplica a
- Source:
- GC.CoreCLR.cs
- Source:
- GC.CoreCLR.cs
- Source:
- GC.CoreCLR.cs
Fuerza una recolección de elementos no utilizados de generación 0 en una generación especificada, en un momento especificado por un valor de GCCollectionMode, con un valor que especifica si la recolección debe ser de bloqueo.
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)
Parámetros
- generation
- Int32
El número de la generación más antigua de elementos no usados para recolectar.
- mode
- GCCollectionMode
Un valor de enumeración que especifica si se fuerza la recolección de elementos (Default o Forced) o si será optimizada (Optimized).
- blocking
- Boolean
true
para realizar una recolección de elementos no utilizados de bloqueo; false
para realizar una recolección de elementos no utilizados en segundo plano cuando sea posible.
Excepciones
Comentarios
En la tabla siguiente se resume la interacción de los mode
parámetros y blocking
:
mode |
blocking es true |
blocking es false |
---|---|---|
Forced o Default | Se realiza una recolección de bloqueo lo antes posible. Si una colección en segundo plano está en curso y generation es 0 o 1, el Collect(Int32, GCCollectionMode, Boolean) método desencadena inmediatamente una colección de bloqueo y devuelve cuando finaliza la colección. Si una colección en segundo plano está en curso y generation es 2, el método espera hasta que finaliza la colección en segundo plano, desencadena una colección de bloqueo de generación 2 y, a continuación, devuelve. |
Se realiza una recolección lo antes posible. El método Collect(Int32, GCCollectionMode, Boolean) solicita una colección en segundo plano, pero esto no se garantiza; puede que aún se realice una colección de bloqueo, dependiendo de las circunstancias. Si una colección en segundo plano ya está en curso, el método vuelve inmediatamente. |
Optimized | Se puede realizar una recolección de bloqueo, dependiendo del estado del recolector de elementos no utilizados y del parámetro generation . El recolector de elementos no utilizados intenta proporcionar un rendimiento óptimo. |
Se puede realizar una recolección, según el estado del recolector de elementos no utilizados. El método Collect(Int32, GCCollectionMode, Boolean) solicita una colección en segundo plano, pero esto no se garantiza; puede que aún se realice una colección de bloqueo, dependiendo de las circunstancias. El recolector de elementos no utilizados intenta proporcionar un rendimiento óptimo. Si una colección en segundo plano ya está en curso, el método vuelve inmediatamente. |
Si una llamada al Collect(Int32, GCCollectionMode, Boolean) método realiza una recolección completa de elementos no utilizados de bloqueo, también puede compactar el montón de objetos grandes estableciendo la GCSettings.LargeObjectHeapCompactionMode propiedad GCLargeObjectHeapCompactionMode.CompactOnce en antes de llamar al Collect método .
Se aplica a
- Source:
- GC.CoreCLR.cs
- Source:
- GC.CoreCLR.cs
- Source:
- GC.CoreCLR.cs
Fuerza una recolección de elementos no utilizados de generación 0 en una generación especificada, en un momento especificado por un valor de GCCollectionMode, con valores que especifican si la recolección debe ser de bloqueo y compactante.
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)
Parámetros
- generation
- Int32
El número de la generación más antigua de elementos no usados para recolectar.
- mode
- GCCollectionMode
Un valor de enumeración que especifica si se fuerza la recolección de elementos (Default o Forced) o si será optimizada (Optimized).
- blocking
- Boolean
true
para realizar una recolección de elementos no utilizados de bloqueo; false
para realizar una recolección de elementos no utilizados en segundo plano cuando sea posible.
- compacting
- Boolean
true
para compactar el montón de objetos pequeños; false
solo para limpiar.
Comentarios
Si blocking
es false
, el GC decide si se debe realizar un fondo o una recolección de elementos no utilizados de bloqueo. Si compacting
es true
, realiza una recolección de elementos no utilizados de bloqueo.
Si compacting
es true
, el tiempo de ejecución compacta el montón de objetos pequeños (SOH). El montón de objetos grandes (LOH) no se compacta a menos que la GCSettings.LargeObjectHeapCompactionMode propiedad esté establecida GCLargeObjectHeapCompactionMode.CompactOnceen . Tenga en cuenta que esto incluye todo el bloqueo de recolecciones de elementos no utilizados, no solo de bloqueo total de recolecciones de elementos no utilizados.
Puede llamar al Collect(Int32, GCCollectionMode, Boolean, Boolean) método para reducir el montón administrado al tamaño más pequeño posible, como se muestra en el fragmento de código siguiente.
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)
Especificar true
para el compacting
argumento garantiza una recolección de elementos no utilizados de bloqueo completo y compactado. Establecer la GCSettings.LargeObjectHeapCompactionMode propiedad en GCLargeObjectHeapCompactionMode.CompactOnce garantiza que se compactan tanto loH como SOH.
Se aplica a
Comentarios de .NET
.NET es un proyecto de código abierto. Seleccione un vínculo para proporcionar comentarios: