MemoryFailPoint Klass

Definition

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

Arv

Object

CriticalFinalizerObject

MemoryFailPoint

Implementeringar

IDisposable

Exempel

MemoryFailPoint gör det möjligt för ett program att sakta ner sig själv för att undvika att minnet börjar ta slut på ett skadat sätt. Den bör användas inom ett lexikalt omfång. I följande exempel startas trådar för att bearbeta objekt i en arbetskö. Innan varje tråd startas kontrolleras de tillgängliga minnesresurserna med hjälp av MemoryFailPoint. Om ett undantag utlöses väntar huvudmetoden tills minnet är tillgängligt innan nästa tråd startas.

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);
    }
}

Kommentarer

När du skapar en instans av MemoryFailPoint klassen skapas en minnesgrind. En minnesgrind söker efter tillräckliga resurser innan du initierar en aktivitet som kräver en stor mängd minne. Om kontrollen misslyckas genereras ett InsufficientMemoryException undantag. Det här undantaget förhindrar att en åtgärd startas och minskar risken för fel på grund av resursbrist. På så sätt kan du minska prestandan för att undvika ett OutOfMemoryException undantag och eventuella skador som kan uppstå vid felaktig hantering av undantaget på godtyckliga platser i koden.

Genom att utlösa ett InsufficientMemoryException undantag kan ett program skilja mellan en uppskattning av att en åtgärd inte kommer att kunna slutföras och en delvis slutförd åtgärd som kan ha skadat programtillståndet. Detta gör att ett program kan minska frekvensen för en pessimistisk eskaleringsprincip, vilket kan kräva att den aktuella AppDomain eller återanvända processen tas bort.

MemoryFailPoint kontrollerar om tillräckligt med minne och på varandra följande virtuellt adressutrymme är tillgängligt i alla skräpinsamlingshögar och kan öka storleken på växlingsfilen. MemoryFailPoint ger inga garantier för den långsiktiga tillgängligheten för minnet under grindens livslängd, men anropare bör alltid använda Dispose metoden för att säkerställa att resurser som är associerade med MemoryFailPoint släpps.

Om du vill använda en minnesgrind måste du skapa ett MemoryFailPoint objekt och ange antalet mb minne som nästa åtgärd förväntas använda. Om tillräckligt med minne inte är tillgängligt genereras ett InsufficientMemoryException undantag.

Parametern för konstruktorn måste vara ett positivt heltal. Ett negativt värde eller 0 genererar ett ArgumentOutOfRangeException undantag.

MemoryFailPoint fungerar med en kornighet på 16 MB. Värden som är mindre än 16 MB behandlas som 16 MB och andra värden behandlas som den näst största multipeln på 16 MB.