MemoryFailPoint MemoryFailPoint MemoryFailPoint MemoryFailPoint Class

定義

操作の実行前に十分なメモリ リソースがあることを確認します。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. 直接的に型を破棄するには、try / catch ブロック内で Dispose メソッドを呼び出します。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では、ゲートの有効期間中、メモリの長期的な可用性については保証されませんが、 DisposeMemoryFailPoint関連付けられているリソースが確実に解放されるように、呼び出し元は常にメソッドを使用する必要があります。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オブジェクトを作成し、次の操作が使用すると予想されるメモリのメガバイト (mb) の数を指定する必要があります。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.

MemoryFailPoint16 MB の粒度で動作します。MemoryFailPoint operates at a granularity of 16 MB. 16 MB より小さい値は 16 MB として処理され、その他の値は 16 MB の次の最大倍数として扱われます。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(Int32) MemoryFailPoint(Int32) MemoryFailPoint(Int32)

正常に実行するために必要なメモリの量を指定して、MemoryFailPoint クラスの新しいインスタンスを初期化します。Initializes a new instance of the MemoryFailPoint class, specifying the amount of memory required for successful execution.

メソッド

Dispose() Dispose() Dispose() Dispose()

MemoryFailPoint によって使用されているすべてのリソースを解放します。Releases all resources used by the MemoryFailPoint.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

指定したオブジェクトが、現在のオブジェクトと等しいかどうかを判断します。Determines whether the specified object is equal to the current object.

(Inherited from Object)
Finalize() Finalize() Finalize() Finalize()

ガベージ コレクターが MemoryFailPoint オブジェクトを再利用しているときに、リソースが解放され、他のクリーンアップ操作が確実に実行されるようにします。Ensures that resources are freed and other cleanup operations are performed when the garbage collector reclaims the MemoryFailPoint object.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

既定のハッシュ関数として機能します。Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

現在のインスタンスの Type を取得します。Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

現在の Object の簡易コピーを作成します。Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

現在のオブジェクトを表す文字列を返します。Returns a string that represents the current object.

(Inherited from Object)

セキュリティ

SecurityPermission
アンマネージコードを呼び出すための。for calling unmanaged code. UnmanagedCode (関連する列挙体)Associated enumeration: UnmanagedCode. セキュリティアクション:LinkDemandSecurity action: LinkDemand

適用対象