GC.WaitForPendingFinalizers Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Sospende il thread corrente fino a quando la coda di finalizzatori non sarà stata svuotata dal thread che la elabora.
public:
static void WaitForPendingFinalizers();public static void WaitForPendingFinalizers ();static member WaitForPendingFinalizers : unit -> unitPublic Shared Sub WaitForPendingFinalizers ()Esempio
Nell'esempio seguente viene illustrato come usare il metodo per sospendere il WaitForPendingFinalizers thread corrente fino al completamento di tutti gli oggetti raccolti.
using namespace System;
ref class MyFinalizeObject
{
private:
// Make this number very large to cause the finalizer to
// do more work.
literal int maxIterations = 10000;
~MyFinalizeObject()
{
Console::WriteLine( "Finalizing a MyFinalizeObject" );
// Do some work.
for ( int i = 0; i < maxIterations; i++ )
{
// This method performs no operation on i, but prevents
// the JIT compiler from optimizing away the code inside
// the loop.
GC::KeepAlive( i );
}
}
};
// You can increase this number to fill up more memory.
const int numMfos = 1000;
// You can increase this number to cause more
// post-finalization work to be done.
const int maxIterations = 100;
int main()
{
MyFinalizeObject^ mfo = nullptr;
// Create and release a large number of objects
// that require finalization.
for ( int j = 0; j < numMfos; j++ )
{
mfo = gcnew MyFinalizeObject;
}
//Release the last object created in the loop.
mfo = nullptr;
//Force garbage collection.
GC::Collect();
// Wait for all finalizers to complete before continuing.
// Without this call to GC::WaitForPendingFinalizers,
// the worker loop below might execute at the same time
// as the finalizers.
// With this call, the worker loop executes only after
// all finalizers have been called.
GC::WaitForPendingFinalizers();
// Worker loop to perform post-finalization code.
for ( int i = 0; i < maxIterations; i++ )
{
Console::WriteLine( "Doing some post-finalize work" );
}
}
using System;
namespace WaitForPendingFinalizersExample
{
class MyWaitForPendingFinalizersClass
{
// You can increase this number to fill up more memory.
const int numMfos = 1000;
// You can increase this number to cause more
// post-finalization work to be done.
const int maxIterations = 100;
static void Main(string[] args)
{
MyFinalizeObject mfo = null;
// Create and release a large number of objects
// that require finalization.
for(int j = 0; j < numMfos; j++)
{
mfo = new MyFinalizeObject();
}
//Release the last object created in the loop.
mfo = null;
//Force garbage collection.
GC.Collect();
// Wait for all finalizers to complete before continuing.
// Without this call to GC.WaitForPendingFinalizers,
// the worker loop below might execute at the same time
// as the finalizers.
// With this call, the worker loop executes only after
// all finalizers have been called.
GC.WaitForPendingFinalizers();
// Worker loop to perform post-finalization code.
for(int i = 0; i < maxIterations; i++)
{
Console.WriteLine("Doing some post-finalize work");
}
}
}
class MyFinalizeObject
{
// Make this number very large to cause the finalizer to
// do more work.
private const int maxIterations = 10000;
~MyFinalizeObject()
{
Console.WriteLine("Finalizing a MyFinalizeObject");
// Do some work.
for(int i = 0; i < maxIterations; i++)
{
// This method performs no operation on i, but prevents
// the JIT compiler from optimizing away the code inside
// the loop.
GC.KeepAlive(i);
}
}
}
}
open System
// You can increase this number to fill up more memory.
let numMfos = 1000
// You can increase this number to cause more
// post-finalization work to be done.
let maxIterations = 100
[<AllowNullLiteral>]
type MyFinalizeObject() =
// Make this number very large to cause the finalizer todo more work.
let maxIterations = 10000
override _.Finalize() =
printfn "Finalizing a MyFinalizeObject"
// Do some work.
for i = 1 to maxIterations do
// This method performs no operation on i, but prevents
// the JIT compiler from optimizing away the code inside
// the loop.
GC.KeepAlive i
let mutable mfo = null
// Create and release a large number of objects
// that require finalization.
for j = 1 to numMfos do
mfo <- MyFinalizeObject()
//Release the last object created in the loop.
mfo <- null
//Force garbage collection.
GC.Collect()
// Wait for all finalizers to complete before continuing.
// Without this call to GC.WaitForPendingFinalizers,
// the worker loop below might execute at the same time
// as the finalizers.
// With this call, the worker loop executes only after
// all finalizers have been called.
GC.WaitForPendingFinalizers()
// Worker loop to perform post-finalization code.
for _ = 1 to maxIterations do
printfn "Doing some post-finalize work"
Namespace WaitForPendingFinalizersExample
Class MyWaitForPendingFinalizersClass
' You can increase this number to fill up more memory.
Private Const numMfos As Integer = 1000
' You can increase this number to cause more
' post-finalization work to be done.
Private Const maxIterations As Integer = 100
Overloads Shared Sub Main()
Dim mfo As MyFinalizeObject = Nothing
' Create and release a large number of objects
' that require finalization.
Dim j As Integer
For j = 0 To numMfos - 1
mfo = New MyFinalizeObject()
Next j
'Release the last object created in the loop.
mfo = Nothing
'Force garbage collection.
GC.Collect()
' Wait for all finalizers to complete before continuing.
' Without this call to GC.WaitForPendingFinalizers,
' the worker loop below might execute at the same time
' as the finalizers.
' With this call, the worker loop executes only after
' all finalizers have been called.
GC.WaitForPendingFinalizers()
' Worker loop to perform post-finalization code.
Dim i As Integer
For i = 0 To maxIterations - 1
Console.WriteLine("Doing some post-finalize work")
Next i
End Sub
End Class
Class MyFinalizeObject
' Make this number very large to cause the finalizer to
' do more work.
Private maxIterations As Integer = 10000
Protected Overrides Sub Finalize()
Console.WriteLine("Finalizing a MyFinalizeObject")
' Do some work.
Dim i As Integer
For i = 0 To maxIterations - 1
' This method performs no operation on i, but prevents
' the JIT compiler from optimizing away the code inside
' the loop.
GC.KeepAlive(i)
Next i
MyBase.Finalize()
End Sub
End Class
End Namespace
Commenti
Quando il Garbage Collector trova oggetti che possono essere recuperati, controlla ogni oggetto per determinare i requisiti di finalizzazione dell'oggetto. Se un oggetto implementa un finalizzatore e non ha disabilitato la finalizzazione chiamando SuppressFinalize, l'oggetto viene inserito in un elenco di oggetti contrassegnati come pronti per la finalizzazione. Garbage Collector chiama i Finalize metodi per gli oggetti in questo elenco e rimuove le voci dall'elenco. Questo metodo blocca fino a quando tutti gli finalizzatori non vengono eseguiti al completamento.
Il thread su cui vengono eseguiti gli finalizzatori non è specificato, quindi non esiste alcuna garanzia che questo metodo venga terminato. Tuttavia, questo thread può essere interrotto da un altro thread mentre il WaitForPendingFinalizers metodo è in corso. Ad esempio, è possibile avviare un altro thread che attende un periodo di tempo e quindi interrompe questo thread se questo thread è ancora sospeso.