MemoryFailPoint 类

参考

定义

命名空间:: System.Runtime

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

Source:: MemoryFailPoint.cs

Source:: MemoryFailPoint.cs

Source:: MemoryFailPoint.cs

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

执行一个操作之前检查是否有足够的内存资源。此类不能被继承。

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

继承: Object

CriticalFinalizerObject
MemoryFailPoint

实现: IDisposable

示例

MemoryFailPoint 使应用程序能够减慢自身速度，以避免以损坏的方式耗尽内存。它应在词法范围内使用。以下示例启动线程以处理工作队列中的项。在启动每个线程之前，使用 MemoryFailPoint检查可用的内存资源。如果引发异常，main方法将等待内存可用，然后再启动下一个线程。

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

注解

注意

此类适用于高级开发。

创建类的 MemoryFailPoint 实例会创建内存门。在启动需要大量内存的活动之前，内存门会检查是否有足够的资源。检查失败会导致InsufficientMemoryException引发异常。此异常可防止启动操作，并减少由于资源不足而失败的可能性。这使你能够降低性能，以避免 OutOfMemoryException 异常和任何状态损坏，这些损坏可能是由于代码中任意位置的异常处理不当而导致的。

重要

此类型实现 IDisposable 接口。在使用完类型后，您应直接或间接释放类型。若要直接释放类型，请在 try/catch 块中调用其 Dispose 方法。若要间接释放类型，请使用 using（在 C# 中）或 Using（在 Visual Basic 中）等语言构造。有关详细信息，请参阅 IDisposable 接口主题中的“使用实现 IDisposable 的对象”一节。

通过引发 InsufficientMemoryException 异常，应用程序可以区分操作无法完成的估计值和可能已损坏应用程序状态的部分完成操作。这允许应用程序减少悲观升级策略的频率，这可能需要卸载当前 AppDomain 或回收进程。

MemoryFailPoint 检查是否在所有垃圾回收堆中都有足够的内存和连续虚拟地址空间，并可能增加交换文件的大小。 MemoryFailPoint 对于入口生存期内内存的长期可用性，不作任何保证，但调用方应始终使用 Dispose 方法来确保释放与 MemoryFailPoint 关联的资源。

若要使用内存门，必须创建一个对象，并指定下一 MemoryFailPoint 操作预期使用的内存 (MB) 。如果没有足够的内存可用，则会引发异常 InsufficientMemoryException 。

构造函数的参数必须是正整数。负值或 0 引发 ArgumentOutOfRangeException 异常。

MemoryFailPoint 以 16 MB 的粒度运行。任何小于 16 MB 的值都被视为 16 MB，其他值被视为 16 MB 的下一个最大倍数。

构造函数

MemoryFailPoint(Int32)

初始化 MemoryFailPoint 类的新实例，指定成功执行所需的内存量。

方法

Dispose()	释放由 MemoryFailPoint 使用的所有资源。
Equals(Object)	确定指定对象是否等于当前对象。 (继承自 Object)
Finalize()	确保垃圾回收器回收 MemoryFailPoint 对象时释放资源并执行其他清理操作。
GetHashCode()	作为默认哈希函数。 (继承自 Object)
GetType()	获取当前实例的 Type。 (继承自 Object)
MemberwiseClone()	创建当前 Object 的浅表副本。 (继承自 Object)
ToString()	返回表示当前对象的字符串。 (继承自 Object)

适用于

通过

MemoryFailPoint 类

定义

示例

注解

构造函数

方法

适用于

其他资源