RegisterForFullGCNotification Methode (Int32, Int32)
Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

GC.RegisterForFullGCNotification-Methode (Int32, Int32)

 

Gibt an, dass eine Garbage Collection-Benachrichtigung ausgelöst werden soll, wenn eine vollständige Garbage Collection durch die Bedingungen begünstigt wird und wenn die Garbage Collection abgeschlossen wurde.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

[SecurityCriticalAttribute]
public static void RegisterForFullGCNotification(
	int maxGenerationThreshold,
	int largeObjectHeapThreshold
)

Parameter

maxGenerationThreshold

Eine Zahl zwischen 1 und 99, die auf der Grundlage der in Generation 2 noch vorhandenen Objekte angibt, wann die Benachrichtigung ausgelöst werden soll.

largeObjectHeapThreshold

Eine Zahl zwischen 1 und 99, die auf der Grundlage der im großen Objektheap reservierten Objekte angibt, wann die Benachrichtigung ausgelöst werden soll.

Exception Condition
ArgumentOutOfRangeException

maxGenerationThreshold oder largeObjectHeapThreshold liegt nicht zwischen 1 und 99.

Wenn Situationen auftreten, in denen eine vollständige Garbagecollection durch die common Language Runtime die Leistung der Anwendung beeinträchtigt, können Sie bestimmen, ob die Common Language Runtime eine vollständige Garbagecollection auslösen und umgehen, indem Sie eine Auflistung vergeblich selbst (mithilfe der Collect Methode) Wenn Bedingungen noch günstig sind.Weitere Informationen über die Bedeutung einer vollständigen Garbagecollection finden Sie unter Garbage Collection-Benachrichtigungen.

Wenn Sie sich für eine Garbage Collection-Benachrichtigung registrieren, können Sie bestimmen, ob das Ereignis, das signalisiert eine bevorstehende Garbagecollection ausgelöst wurde durch Überprüfen des Status der Garbage Collection-Benachrichtigung.Dieses Muster ähnelt das Betriebssystem wie Benachrichtigungen über unzureichenden Arbeitsspeicher überwacht.

Verwenden Sie die folgenden Richtlinien zur Angabe der maxGenerationThreshold und largeObjectHeapThreshold Parameter:

  • Je größer der Schwellenwert, je weiter weg bei der Collection wahrscheinlich erfolgt, und desto früher wird die Benachrichtigung ausgelöst werden.

    Ein größerer Schwellenwert bietet mehrere Möglichkeiten für die Laufzeit eine bevorstehende Garbage Collection zu überprüfen.Dies erhöht die Wahrscheinlichkeit, dass Sie benachrichtigt werden soll.Allerdings sollten Sie nicht zu hohen Schwellenwert festlegen, da, die eine längere Wartezeit führt, bevor die Common Language Runtime die nächste Collection ausgelöst wird.

    Wenn Sie eine Auflistung selbst mit einem hohen Schwellenwert Benachrichtigung auslösen, werden mehr Objekte freigegeben, als durch die Laufzeit weiter Auflistung freigegeben werden würde.

  • Je kleiner werden der Schwellenwert, desto größer ist die Wahrscheinlichkeit, den eine Auflistung schneller ausgeführt werden und die Benachrichtigung später ausgelöst werden.

Das folgende Beispiel zeigt, wie eine Garbage Collection-Benachrichtigung registrieren und Starten eines Threads zum Überwachen des Status der Garbage Collection-Benachrichtigung.Dieses Codebeispiel ist Teil eines größeren Beispiels für Garbage Collection-Benachrichtigungen Thema.

using System;
using System.Collections.Generic;
using System.Threading;

namespace GCNotify
{
    class Program
    {
        // Variable for continual checking in the 
        // While loop in the WaitForFullGCProc method.
        static bool checkForNotify = false;

        // Variable for suspending work 
        // (such servicing allocated server requests)
        // after a notification is received and then 
        // resuming allocation after inducing a garbage collection.
        static bool bAllocate = false;

        // Variable for ending the example.
        static bool finalExit = false;

        // Collection for objects that  
        // simulate the server request workload.
        static List<byte[]> load = new List<byte[]>();


        public static void Main(string[] args)
        {
            try
            {
                // Register for a notification. 
                GC.RegisterForFullGCNotification(10, 10);
                Console.WriteLine("Registered for GC notification.");

                checkForNotify = true;
                bAllocate = true;

                // Start a thread using WaitForFullGCProc.
                Thread thWaitForFullGC = new Thread(new ThreadStart(WaitForFullGCProc));
                thWaitForFullGC.Start();

                // While the thread is checking for notifications in
                // WaitForFullGCProc, create objects to simulate a server workload.
                try
                {

                    int lastCollCount = 0;
                    int newCollCount = 0;


                    while (true)
                    {
                        if (bAllocate)
                        {
                            load.Add(new byte[1000]);
                            newCollCount = GC.CollectionCount(2);
                            if (newCollCount != lastCollCount)
                            {
                                // Show collection count when it increases:
                                Console.WriteLine("Gen 2 collection count: {0}", GC.CollectionCount(2).ToString());
                                lastCollCount = newCollCount;
                            }

                            // For ending the example (arbitrary).
                            if (newCollCount == 500)
                            {
                                finalExit = true;
                                checkForNotify = false;
                                break;
                            }
                        }
                    }

                }
                catch (OutOfMemoryException)
                {
                    Console.WriteLine("Out of memory.");
                }


                finalExit = true;
                checkForNotify = false;
                GC.CancelFullGCNotification();

            }
            catch (InvalidOperationException invalidOp)
            {

                Console.WriteLine("GC Notifications are not supported while concurrent GC is enabled.\n"
                    + invalidOp.Message);
            }
        }

        public static void OnFullGCApproachNotify()
        {

            Console.WriteLine("Redirecting requests.");

            // Method that tells the request queuing  
            // server to not direct requests to this server. 
            RedirectRequests();

            // Method that provides time to 
            // finish processing pending requests. 
            FinishExistingRequests();

            // This is a good time to induce a GC collection
            // because the runtime will induce a full GC soon.
            // To be very careful, you can check precede with a
            // check of the GC.GCCollectionCount to make sure
            // a full GC did not already occur since last notified.
            GC.Collect();
            Console.WriteLine("Induced a collection.");

        }


        public static void OnFullGCCompleteEndNotify()
        {
            // Method that informs the request queuing server
            // that this server is ready to accept requests again.
            AcceptRequests();
            Console.WriteLine("Accepting requests again.");
        }

        public static void WaitForFullGCProc()
        {
            while (true)
            {
                // CheckForNotify is set to true and false in Main.
                while (checkForNotify)
                {
                    // Check for a notification of an approaching collection.
                    GCNotificationStatus s = GC.WaitForFullGCApproach();
                    if (s == GCNotificationStatus.Succeeded)
                    {
                        Console.WriteLine("GC Notification raised.");
                        OnFullGCApproachNotify();
                    }
                    else if (s == GCNotificationStatus.Canceled)
                    {
                        Console.WriteLine("GC Notification cancelled.");
                        break;
                    }
                    else
                    {
                        // This can occur if a timeout period
                        // is specified for WaitForFullGCApproach(Timeout) 
                        // or WaitForFullGCComplete(Timeout)  
                        // and the time out period has elapsed. 
                        Console.WriteLine("GC Notification not applicable.");
                        break;
                    }

                    // Check for a notification of a completed collection.
                    s = GC.WaitForFullGCComplete();
                    if (s == GCNotificationStatus.Succeeded)
                    {
                        Console.WriteLine("GC Notifiction raised.");
                        OnFullGCCompleteEndNotify();
                    }
                    else if (s == GCNotificationStatus.Canceled)
                    {
                        Console.WriteLine("GC Notification cancelled.");
                        break;
                    }
                    else
                    {
                        // Could be a time out.
                        Console.WriteLine("GC Notification not applicable.");
                        break;
                    }
                }


                Thread.Sleep(500);
                // FinalExit is set to true right before  
                // the main thread cancelled notification.
                if (finalExit)
                {
                    break;
                }
            }

        }

        private static void RedirectRequests()
        {
            // Code that sends requests
            // to other servers.

            // Suspend work.
            bAllocate = false;

        }

        private static void FinishExistingRequests()
        {
            // Code that waits a period of time
            // for pending requests to finish.

            // Clear the simulated workload.
            load.Clear();

        }

        private static void AcceptRequests()
        {
            // Code that resumes processing
            // requests on this server.

            // Resume work.
            bAllocate = true;

        }
    }
}

LinkDemand

for full trust for the immediate caller.This member cannot be used by partially trusted code.

SecurityCriticalAttribute

requires full trust for the immediate caller.This member cannot be used by partially trusted or transparent code.

.NET Framework
Verfügbar seit 2.0
Zurück zum Anfang
Anzeigen:
© 2016 Microsoft