MemoryFailPoint Klas

Definitie

public ref class MemoryFailPoint sealed : System::Runtime::ConstrainedExecution::CriticalFinalizerObject, IDisposable

public sealed class MemoryFailPoint : System.Runtime.ConstrainedExecution.CriticalFinalizerObject, IDisposable

type MemoryFailPoint = class
    inherit CriticalFinalizerObject
    interface IDisposable

Public NotInheritable Class MemoryFailPoint
Inherits CriticalFinalizerObject
Implements IDisposable

Overname

Object

CriticalFinalizerObject

MemoryFailPoint

Implementeringen

IDisposable

Voorbeelden

MemoryFailPoint hiermee kan een toepassing zichzelf vertragen om te voorkomen dat er onvoldoende geheugen beschikbaar is op een beschadigde manier. Deze moet worden gebruikt binnen een lexical bereik. In het volgende voorbeeld worden threads gestart om items in een werkwachtrij te verwerken. Voordat elke thread wordt gestart, worden de beschikbare geheugenbronnen gecontroleerd met behulp van MemoryFailPoint. Als er een uitzondering wordt gegenereerd, wacht de hoofdmethode totdat het geheugen beschikbaar is voordat de volgende thread wordt gestart.

using System;
using System.Runtime;
using System.IO;
using System.Threading;
using System.Collections.Generic;
using System.Collections;

class MemoryFailPointExample
{
    // Allocate in chunks of 64 megabytes.
    private const uint chunkSize = 64 << 20;
    // Use more than the total user-available address space (on 32 bit machines)
    // to drive towards getting an InsufficientMemoryException.
    private const uint numWorkItems = 1 + ((1U << 31) / chunkSize);
    static Queue workQueue = new Queue(50);

    // This value can be computed separately and hard-coded into the application.
    // The method is included to illustrate the technique.
    private static int EstimateMemoryUsageInMB()
    {
        int memUsageInMB = 0;

        long memBefore = GC.GetTotalMemory(true);
        int numGen0Collections = GC.CollectionCount(0);
        // Execute a test version of the method to estimate memory requirements.
        // This test method only exists to determine the memory requirements.
        ThreadMethod();
        // Includes garbage generated by the worker function.
        long memAfter = GC.GetTotalMemory(false);
        // If a garbage collection occurs during the measuring, you might need a greater memory requirement.
        Console.WriteLine("Did a GC occur while measuring?  {0}", numGen0Collections == GC.CollectionCount(0));
        // Set the field used as the parameter for the MemoryFailPoint constructor.
        long memUsage = (memAfter - memBefore);
        if (memUsage < 0)
        {
            Console.WriteLine("GC's occurred while measuring memory usage.  Try measuring again.");
            memUsage = 1 << 20;
        }

        // Round up to the nearest MB.
        memUsageInMB = (int)(1 + (memUsage >> 20));
        Console.WriteLine("Memory usage estimate: {0} bytes, rounded to {1} MB", memUsage, memUsageInMB);
        return memUsageInMB;
    }

    static void Main()
    {
        Console.WriteLine("Attempts to allocate more than 2 GB of memory across worker threads.");
        int memUsageInMB = EstimateMemoryUsageInMB();

        // For a production application consider using the threadpool instead.
        Thread[] threads = new Thread[numWorkItems];
        // Create a work queue to be processed by multiple threads.
        int n = 0;
        for (n = 0; n < numWorkItems; n++)
            workQueue.Enqueue(n);
        // Continue to launch threads until the work queue is empty.
        while (workQueue.Count > 0)
        {
            Console.WriteLine(" GC heap (live + garbage): {0} MB", GC.GetTotalMemory(false) >> 20);
            MemoryFailPoint memFailPoint = null;
            try
            {
                // Check for available memory.
                memFailPoint = new MemoryFailPoint(memUsageInMB);
                n = (int)workQueue.Dequeue();
                threads[n] =
                    new Thread(new ParameterizedThreadStart(ThreadMethod));
                WorkerState state = new WorkerState(n, memFailPoint);
                threads[n].Start(state);
                Thread.Sleep(10);
            }
            catch (InsufficientMemoryException e)
            {
                // MemoryFailPoint threw an exception, handle by sleeping for a while,  then
                // continue processing the queue.
                Console.WriteLine("Expected InsufficientMemoryException thrown.  Message: " + e.Message);
                // We could optionally sleep until a running worker thread
                // has finished, like this:  threads[joinCount++].Join();
                Thread.Sleep(1000);
            }
        }

        Console.WriteLine("WorkQueue is empty - blocking to ensure all threads quit (each thread sleeps for 10 seconds)");
        foreach (Thread t in threads)
            t.Join();
        Console.WriteLine("All worker threads are finished - exiting application.");
    }

    // Test version of the working code to determine memory requirements.
    static void ThreadMethod()
    {
        byte[] bytes = new byte[chunkSize];
    }

    internal class WorkerState
    {
        internal int _threadNumber;
        internal MemoryFailPoint _memFailPoint;

        internal WorkerState(int threadNumber, MemoryFailPoint memoryFailPoint)
        {
            _threadNumber = threadNumber;
            _memFailPoint = memoryFailPoint;
        }

        internal int ThreadNumber
        {
            get { return _threadNumber; }
        }

        internal MemoryFailPoint MemoryFailPoint
        {
            get { return _memFailPoint; }
        }
    }

    // The method that does the work.
    static void ThreadMethod(Object o)
    {
        WorkerState state = (WorkerState)o;
        Console.WriteLine("Executing ThreadMethod, " +
            "thread number {0}.", state.ThreadNumber);
        byte[] bytes = null;
        try
        {
            bytes = new byte[chunkSize];
            // Allocated all the memory needed for this workitem.
            // Now dispose of the MemoryFailPoint, then process the workitem.
            state.MemoryFailPoint.Dispose();
        }
        catch (OutOfMemoryException oom)
        {
            Console.Beep();
            Console.WriteLine("Unexpected OutOfMemory exception thrown: " + oom);
        }

        // Do work here, possibly taking a lock if this app needs
        // synchronization between worker threads and/or the main thread.

        // Keep the thread alive for awhile to simulate a running thread.
        Thread.Sleep(10000);

        // A real thread would use the byte[], but to be an illustrative sample,
        // explicitly keep the byte[] alive to help exhaust the memory.
        GC.KeepAlive(bytes);
        Console.WriteLine("Thread {0} is finished.", state.ThreadNumber);
    }
}

Opmerkingen

Als u een exemplaar van de MemoryFailPoint klasse maakt, wordt er een geheugenpoort gemaakt. Een geheugenpoort controleert op voldoende resources voordat een activiteit wordt gestart waarvoor een grote hoeveelheid geheugen is vereist. Als de controle mislukt, wordt er een InsufficientMemoryException uitzondering gegenereerd. Deze uitzondering voorkomt dat een bewerking wordt gestart en vermindert de kans op fouten vanwege een gebrek aan resources. Hierdoor kunt u de prestaties verminderen om een OutOfMemoryException uitzondering en eventuele statusbeschadiging te voorkomen die kunnen voortvloeien uit een onjuiste verwerking van de uitzondering op willekeurige locaties in uw code.

Door een InsufficientMemoryException uitzondering te genereren, kan een toepassing onderscheid maken tussen een schatting dat een bewerking niet kan worden voltooid en een gedeeltelijk voltooide bewerking die de toepassingsstatus mogelijk heeft beschadigd. Hierdoor kan een toepassing de frequentie van een pessimistisch escalatiebeleid verminderen, wat mogelijk vereist is om het huidige AppDomain proces te lossen of het proces te recyclen.

MemoryFailPoint controleert of voldoende geheugen en opeenvolgende virtuele adresruimte beschikbaar zijn in alle garbagecollection-heaps en kan de grootte van het wisselbestand vergroten. MemoryFailPoint biedt geen garanties met betrekking tot de langetermijnbeschikbaarheid van het geheugen tijdens de levensduur van de poort, maar bellers moeten altijd de Dispose methode gebruiken om ervoor te zorgen dat resources die zijn MemoryFailPoint gekoppeld aan worden vrijgegeven.

Als u een geheugenpoort wilt gebruiken, moet u een MemoryFailPoint object maken en het aantal megabytes (MB) aan geheugen opgeven dat de volgende bewerking naar verwachting zal gebruiken. Als er onvoldoende geheugen beschikbaar is, wordt er een InsufficientMemoryException uitzondering gegenereerd.

De parameter van de constructor moet een positief geheel getal zijn. Een negatieve waarde of 0 verhoogt een ArgumentOutOfRangeException uitzondering.

MemoryFailPoint werkt met een granulariteit van 16 MB. Waarden die kleiner zijn dan 16 MB, worden behandeld als 16 MB en andere waarden worden beschouwd als het eerstvolgende grootste veelvoud van 16 MB.