MemoryFailPoint Класс

Определение

Проверяет наличие достаточного количество ресурсов памяти перед выполнением операции.Checks for sufficient memory resources before executing an operation. Этот класс не наследуется.This class cannot be inherited.

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
Наследование
Реализации

Примеры

MemoryFailPoint позволяет приложению замедлять работу, чтобы избежать повреждения памяти.MemoryFailPoint enables an application to slow itself to avoid running out of memory in a corrupting manner. Он должен использоваться в лексической области.It should be used within a lexical scope. В следующем примере потоки загружаются для обработки элементов в рабочей очереди.The following example launches threads to process items in a work queue. Перед запуском каждого потока проверяются доступные ресурсы памяти с помощью MemoryFailPoint .Before each thread is launched, the available memory resources are checked using MemoryFailPoint. При возникновении исключения метод Main ждет, пока память не будет доступна, прежде чем запускать следующий поток.If an exception is thrown, the main method waits until memory is available before launching the next thread.

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

Комментарии

Примечание

Этот класс предназначен для использования в расширенной разработке.This class is intended for use in advanced development.

Создание экземпляра MemoryFailPoint класса создает шлюз памяти.Creating an instance of the MemoryFailPoint class creates a memory gate. Шлюз памяти проверяет наличие достаточного количества ресурсов перед запуском действия, требующего большого объема памяти.A memory gate checks for sufficient resources before initiating an activity that requires a large amount of memory. Сбой проверки приводит к возникновению InsufficientMemoryException исключения.Failing the check results in an InsufficientMemoryException exception being thrown. Это исключение предотвращает запуск операции и сокращает вероятность сбоя из-за нехватки ресурсов.This exception prevents an operation from being started and reduces the possibility of failure due to lack of resources. Это позволяет снизить производительность во избежание OutOfMemoryException исключения и повреждения состояния, которые могут быть вызваны неправильной обработкой исключения в произвольных местах кода.This enables you decrease performance to avoid an OutOfMemoryException exception and any state corruption that may result from improper handling of the exception in arbitrary locations in your code.

Важно!

Этот тип реализует интерфейс IDisposable.This type implements the IDisposable interface. По окончании использования выдаленную ему память следует прямо или косвенно освободить.When you have finished using the type, you should dispose of it either directly or indirectly. Чтобы сделать это прямо, вызовите его метод Dispose в блоке try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Чтобы сделать это косвенно, используйте языковые конструкции, такие как using (в C#) или Using (в Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Дополнительные сведения см. в разделе "Использование объекта, реализующего IDisposable" в статье об интерфейсе IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Вызывая InsufficientMemoryException исключение, приложение может различать оценку того, что операция не может завершиться, и частично завершенная операция, которая могла повредить состояние приложения.By throwing an InsufficientMemoryException exception, an application can distinguish between an estimate that an operation will not be able to complete and a partially completed operation that may have corrupted the application state. Это позволяет приложению уменьшить частоту политики пессимистического укрупнения, которая может потребовать выгрузки текущего AppDomain или повторного запуска процесса.This allows an application to reduce the frequency of a pessimistic escalation policy, which may require unloading the current AppDomain or recycling the process.

MemoryFailPoint проверяет, достаточно ли памяти и последовательных виртуальных адресных пространств во всех кучах сборки мусора, и может увеличить размер файла подкачки.MemoryFailPoint checks to see whether sufficient memory and consecutive virtual address space are available in all garbage collection heaps, and may increase the size of the swap file. MemoryFailPoint не дает никаких гарантий относительно долгосрочной доступности памяти в течение времени существования шлюза, но вызывающие объекты всегда должны использовать метод, Dispose чтобы обеспечить освобождение ресурсов, связанных с MemoryFailPoint .MemoryFailPoint makes no guarantees regarding the long-term availability of the memory during the lifetime of the gate, but callers should always use the Dispose method to ensure that resources associated with MemoryFailPoint are released.

Чтобы использовать шлюз памяти, необходимо создать MemoryFailPoint объект и указать количество мегабайтов (МБ) памяти, которое должна использовать следующая операция.To use a memory gate, you must create a MemoryFailPoint object and specify the number of megabytes (MB) of memory that the next operation is expected to use. Если недоступно достаточно памяти, InsufficientMemoryException возникает исключение.If enough memory is not available, an InsufficientMemoryException exception is thrown.

Параметр конструктора должен быть положительным целым числом.The parameter of the constructor must be a positive integer. Отрицательное значение вызывает ArgumentOutOfRangeException исключение.A negative value raises an ArgumentOutOfRangeException exception.

MemoryFailPoint работает с гранулярностью в 16 МБ.MemoryFailPoint operates at a granularity of 16 MB. Все значения меньше 16 МБ обрабатываются как 16 МБ, а другие значения рассматриваются как следующие большие, кратные 16 МБ.Any values smaller than 16 MB are treated as 16 MB, and other values are treated as the next largest multiple of 16 MB.

Конструкторы

MemoryFailPoint(Int32)

Инициализирует новый экземпляр класса MemoryFailPoint, указывающий объем памяти, необходимый для успешного выполнения.Initializes a new instance of the MemoryFailPoint class, specifying the amount of memory required for successful execution.

Методы

Dispose()

Освобождает все ресурсы, занятые модулем MemoryFailPoint.Releases all resources used by the MemoryFailPoint.

Equals(Object)

Определяет, равен ли указанный объект текущему объекту.Determines whether the specified object is equal to the current object.

(Унаследовано от Object)
Finalize()

Обеспечивает освобождение ресурсов и выполнение других завершающих операций, когда сборщик мусора восстанавливает объект MemoryFailPoint.Ensures that resources are freed and other cleanup operations are performed when the garbage collector reclaims the MemoryFailPoint object.

GetHashCode()

Служит хэш-функцией по умолчанию.Serves as the default hash function.

(Унаследовано от Object)
GetType()

Возвращает объект Type для текущего экземпляра.Gets the Type of the current instance.

(Унаследовано от Object)
MemberwiseClone()

Создает неполную копию текущего объекта Object.Creates a shallow copy of the current Object.

(Унаследовано от Object)
ToString()

Возвращает строку, представляющую текущий объект.Returns a string that represents the current object.

(Унаследовано от Object)

Применяется к